home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 March / macformat-022.iso / Shareware City / Developers / src / out-of-phase-102-c / OutOfPhase 1.02 Source / OutOfPhase Folder / ModulationOscControl.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-23  |  81.2 KB  |  2,105 lines  |  [TEXT/KAHL]
  1. /* ModulationOscControl.c */
  2. /*****************************************************************************/
  3. /*                                                                           */
  4. /*    Out Of Phase:  Digital Music Synthesis on General Purpose Computers    */
  5. /*    Copyright (C) 1994  Thomas R. Lawrence                                 */
  6. /*                                                                           */
  7. /*    This program is free software; you can redistribute it and/or modify   */
  8. /*    it under the terms of the GNU General Public License as published by   */
  9. /*    the Free Software Foundation; either version 2 of the License, or      */
  10. /*    (at your option) any later version.                                    */
  11. /*                                                                           */
  12. /*    This program is distributed in the hope that it will be useful,        */
  13. /*    but WITHOUT ANY WARRANTY; without even the implied warranty of         */
  14. /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          */
  15. /*    GNU General Public License for more details.                           */
  16. /*                                                                           */
  17. /*    You should have received a copy of the GNU General Public License      */
  18. /*    along with this program; if not, write to the Free Software            */
  19. /*    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.              */
  20. /*                                                                           */
  21. /*    Thomas R. Lawrence can be reached at tomlaw@world.std.com.             */
  22. /*                                                                           */
  23. /*****************************************************************************/
  24.  
  25. #include "MiscInfo.h"
  26. #include "Audit.h"
  27. #include "Debug.h"
  28. #include "Definitions.h"
  29.  
  30. #include "ModulationOscControl.h"
  31. #include "ModulationSpecifier.h"
  32. #include "WaveTableOscControl.h"
  33. #include "SampleOscControl.h"
  34. #include "FastModulation.h"
  35. #include "OscillatorSpecifier.h"
  36. #include "Array.h"
  37. #include "Memory.h"
  38. #include "LFOListSpecifier.h"
  39. #include "LFOGenerator.h"
  40. #include "EnvelopeState.h"
  41. #include "Envelope.h"
  42. #include "ErrorDaemon.h"
  43.  
  44.  
  45. typedef struct
  46.     {
  47.         OscillatorTypes                        OscillatorType;
  48.         union
  49.             {
  50.                 WaveTableTemplateRec*            WaveTableTemplate;
  51.                 SampleTemplateRec*                SampleTemplate;
  52.             } u;
  53.     } TemplateElemRec;
  54.  
  55.  
  56. struct ModOscTemplateRec
  57.     {
  58.         long                                            NumberOfOscillators;
  59.  
  60.         /* this is an array of records, NumberOfOscillators elements long */
  61.         TemplateElemRec*                    TemplateArray;
  62.  
  63.         /* this is an array of integers, one for each template */
  64.         long*                                            PhaseGenNumElements;
  65.         /* these are arrays of arrays.  there is one array for each template, and */
  66.         /* that array has PhaseGenNumElements[i] elements in it */
  67.         ModulationTypes**                    PhaseGenModulateHow;
  68.         long**                                        PhaseGenIndirectionTable;
  69.         EnvelopeRec***                        PhaseGenScalingFactorEnvelope;
  70.         LFOListSpecRec***                    PhaseGenScalingFactorLFOList;
  71.         EnvelopeRec***                        PhaseGenOriginAdjustEnvelope;
  72.         LFOListSpecRec***                    PhaseGenOriginAdjustLFOList;
  73.  
  74.         /* this is an array of integers, one for each template */
  75.         long*                                            OutputNumElements;
  76.         /* these are arrays of arrays.  there is one array for each template, and */
  77.         /* that array has OutputNumElements[i] elements in it */
  78.         ModulationTypes**                    OutputModulateHow;
  79.         long**                                        OutputIndirectionTable;
  80.         EnvelopeRec***                        OutputScalingFactorEnvelope;
  81.         LFOListSpecRec***                    OutputScalingFactorLFOList;
  82.         EnvelopeRec***                        OutputOriginAdjustEnvelope;
  83.         LFOListSpecRec***                    OutputOriginAdjustLFOList;
  84.  
  85.         /* this flag indicates whether we are doing stereo playback or not */
  86.         MyBoolean                                    StereoPlayback;
  87.  
  88.         /* envelope update rate */
  89.         float                                            TicksPerSecond;
  90.  
  91.         /* list link */
  92.         ModOscTemplateRec*                Next;
  93.     };
  94.  
  95.  
  96. typedef struct
  97.     {
  98.         OscillatorTypes                        OscillatorType;
  99.         union
  100.             {
  101.                 WaveTableStateRec*                WaveTableState;
  102.                 SampleStateRec*                        SampleState;
  103.             } u;
  104.     } StateElemRec;
  105.  
  106.  
  107. struct ModOscStateRec
  108.     {
  109.         /* array of state objects, one for each oscillator (Template.NumberOfOscillators) */
  110.         StateElemRec*                            StateArray;
  111.  
  112.         /* this is an array of fast fixeds, one for each oscillator.  it remembers the */
  113.         /* previous output values of all oscillators for the purposes of feedback. */
  114.         float*                                        OldValues;
  115.  
  116.         /* this is like OldValues, except that the oscillator values from the current */
  117.         /* stage of execution are put in here.  this is to avoid changing the OldValues */
  118.         /* array while a synthesis step is in progress, so that modulation with feedback */
  119.         /* is order independent.  at the end of the cycle, this and OldValues are */
  120.         /* swapped.  (we don't want to allocate an array each cycle, so we keep this one */
  121.         /* around to save time.) */
  122.         float*                                        BuildOldValues;
  123.  
  124.         /* a copy of the template information.  do NOT dispose any of the pointers in it */
  125.         ModOscTemplateRec                    Template;
  126.  
  127.         /* workspace for each envelope iteration of phase gen modulation parameters */
  128.         float**                                        PhaseGenModulationScaling;
  129.         float**                                        PhaseGenModulationOrigin;
  130.         EvalEnvelopeRec***                PhaseGenScalingFactorEnvelope;
  131.         LFOGenRec***                            PhaseGenScalingFactorLFO;
  132.         EvalEnvelopeRec***                PhaseGenOriginAdjustEnvelope;
  133.         LFOGenRec***                            PhaseGenOriginAdjustLFO;
  134.  
  135.         /* workspace for each envelope iteration of output modulation parameters */
  136.         float**                                        OutputModulationScaling;
  137.         float**                                        OutputModulationOrigin;
  138.         EvalEnvelopeRec***                OutputScalingFactorEnvelope;
  139.         LFOGenRec***                            OutputScalingFactorLFO;
  140.         EvalEnvelopeRec***                OutputOriginAdjustEnvelope;
  141.         LFOGenRec***                            OutputOriginAdjustLFO;
  142.  
  143.         /* list thing */
  144.         ModOscStateRec*                        Next;
  145.     };
  146.  
  147.  
  148.  
  149.  
  150. static ModOscTemplateRec*                TemplateFreeList = NIL;
  151. static ModOscStateRec*                    StateFreeList = NIL;
  152.  
  153.  
  154. /* get rid of all cached memory for state or template records */
  155. void                                    FlushModOscControl(void)
  156.     {
  157.         while (TemplateFreeList != NIL)
  158.             {
  159.                 ModOscTemplateRec*    Temp;
  160.  
  161.                 Temp = TemplateFreeList;
  162.                 TemplateFreeList = TemplateFreeList->Next;
  163.                 ReleasePtr((char*)Temp);
  164.             }
  165.  
  166.         while (StateFreeList != NIL)
  167.             {
  168.                 ModOscStateRec*            Temp;
  169.  
  170.                 Temp = StateFreeList;
  171.                 StateFreeList = StateFreeList->Next;
  172.                 ReleasePtr((char*)Temp);
  173.             }
  174.     }
  175.  
  176.  
  177. #if DEBUG
  178. static void                        ValidateTemplate(ModOscTemplateRec* Template)
  179.     {
  180.         ModOscTemplateRec*    Scan;
  181.  
  182.         CheckPtrExistence(Template);
  183.         Scan = TemplateFreeList;
  184.         while (Scan != NIL)
  185.             {
  186.                 if (Scan == Template)
  187.                     {
  188.                         PRERR(ForceAbort,"ValidateTemplate:  template is on free list");
  189.                     }
  190.                 Scan = Scan->Next;
  191.             }
  192.     }
  193. #else
  194. #define ValidateTemplate(x) ((void)0)
  195. #endif
  196.  
  197.  
  198. #if DEBUG
  199. static void                        ValidateState(ModOscStateRec* State)
  200.     {
  201.         ModOscStateRec*            Scan;
  202.  
  203.         CheckPtrExistence(State);
  204.         Scan = StateFreeList;
  205.         while (Scan != NIL)
  206.             {
  207.                 if (Scan == State)
  208.                     {
  209.                         PRERR(ForceAbort,"ValidateState:  state is on free list");
  210.                     }
  211.                 Scan = Scan->Next;
  212.             }
  213.     }
  214. #else
  215. #define ValidateState(x) ((void)0)
  216. #endif
  217.  
  218.  
  219. /* perform one envelope update cycle */
  220. void                                    UpdateModOscEnvelopes(ModOscStateRec* State)
  221.     {
  222.         long                                Scan;
  223.  
  224.         CheckPtrExistence(State);
  225.         ValidateState(State);
  226.  
  227.         for (Scan = 0; Scan < State->Template.NumberOfOscillators; Scan += 1)
  228.             {
  229.                 long                                Index;
  230.  
  231.                 PRNGCHK(State->StateArray,&(State->StateArray[Scan]),
  232.                     sizeof(State->StateArray[Scan]));
  233.                 ERROR((State->StateArray[Scan].OscillatorType != eOscillatorSampled)
  234.                     && (State->StateArray[Scan].OscillatorType != eOscillatorWaveTable),
  235.                     PRERR(ForceAbort,"UpdateModOscEnvelopes:  bad oscillator type"));
  236.                 if (State->StateArray[Scan].OscillatorType == eOscillatorSampled)
  237.                     {
  238.                         UpdateSampleEnvelopes(State->StateArray[Scan].u.SampleState);
  239.                     }
  240.                  else
  241.                     {
  242.                         UpdateWaveTableEnvelopes(State->StateArray[Scan].u.WaveTableState);
  243.                     }
  244.                 for (Index = 0; Index < State->Template.PhaseGenNumElements[Scan]; Index += 1)
  245.                     {
  246.                         PRNGCHK(State->PhaseGenModulationScaling,
  247.                             &(State->PhaseGenModulationScaling[Scan]),
  248.                             sizeof(State->PhaseGenModulationScaling[Scan]));
  249.                         PRNGCHK(State->PhaseGenModulationScaling[Scan],
  250.                             &(State->PhaseGenModulationScaling[Scan][Index]),
  251.                             sizeof(State->PhaseGenModulationScaling[Scan][Index]));
  252.                         PRNGCHK(State->PhaseGenScalingFactorLFO,
  253.                             &(State->PhaseGenScalingFactorLFO[Scan]),
  254.                             sizeof(State->PhaseGenScalingFactorLFO[Scan]));
  255.                         PRNGCHK(State->PhaseGenScalingFactorLFO[Scan],
  256.                             &(State->PhaseGenScalingFactorLFO[Scan][Index]),
  257.                             sizeof(State->PhaseGenScalingFactorLFO[Scan][Index]));
  258.                         PRNGCHK(State->PhaseGenScalingFactorEnvelope,
  259.                             &(State->PhaseGenScalingFactorEnvelope[Scan]),
  260.                             sizeof(State->PhaseGenScalingFactorEnvelope[Scan]));
  261.                         PRNGCHK(State->PhaseGenScalingFactorEnvelope[Scan],
  262.                             &(State->PhaseGenScalingFactorEnvelope[Scan][Index]),
  263.                             sizeof(State->PhaseGenScalingFactorEnvelope[Scan][Index]));
  264.                         State->PhaseGenModulationScaling[Scan][Index]
  265.                             = FastFixed2Float(LFOGenUpdateCycle(
  266.                                 State->PhaseGenScalingFactorLFO[Scan][Index],
  267.                                 EnvelopeUpdate(State->PhaseGenScalingFactorEnvelope[Scan][Index])));
  268.                         PRNGCHK(State->PhaseGenModulationOrigin,
  269.                             &(State->PhaseGenModulationOrigin[Scan]),
  270.                             sizeof(State->PhaseGenModulationOrigin[Scan]));
  271.                         PRNGCHK(State->PhaseGenModulationOrigin[Scan],
  272.                             &(State->PhaseGenModulationOrigin[Scan][Index]),
  273.                             sizeof(State->PhaseGenModulationOrigin[Scan][Index]));
  274.                         PRNGCHK(State->PhaseGenOriginAdjustLFO,
  275.                             &(State->PhaseGenOriginAdjustLFO[Scan]),
  276.                             sizeof(State->PhaseGenOriginAdjustLFO[Scan]));
  277.                         PRNGCHK(State->PhaseGenOriginAdjustLFO[Scan],
  278.                             &(State->PhaseGenOriginAdjustLFO[Scan][Index]),
  279.                             sizeof(State->PhaseGenOriginAdjustLFO[Scan][Index]));
  280.                         PRNGCHK(State->PhaseGenOriginAdjustEnvelope,
  281.                             &(State->PhaseGenOriginAdjustEnvelope[Scan]),
  282.                             sizeof(State->PhaseGenOriginAdjustEnvelope[Scan]));
  283.                         PRNGCHK(State->PhaseGenOriginAdjustEnvelope[Scan],
  284.                             &(State->PhaseGenOriginAdjustEnvelope[Scan][Index]),
  285.                             sizeof(State->PhaseGenOriginAdjustEnvelope[Scan][Index]));
  286.                         State->PhaseGenModulationOrigin[Scan][Index]
  287.                             = FastFixed2Float(LFOGenUpdateCycle(
  288.                                 State->PhaseGenOriginAdjustLFO[Scan][Index],
  289.                                 EnvelopeUpdate(State->PhaseGenOriginAdjustEnvelope[Scan][Index])));
  290.                     }
  291.                 for (Index = 0; Index < State->Template.OutputNumElements[Scan]; Index += 1)
  292.                     {
  293.                         PRNGCHK(State->OutputModulationScaling,
  294.                             &(State->OutputModulationScaling[Scan]),
  295.                             sizeof(State->OutputModulationScaling[Scan]));
  296.                         PRNGCHK(State->OutputModulationScaling[Scan],
  297.                             &(State->OutputModulationScaling[Scan][Index]),
  298.                             sizeof(State->OutputModulationScaling[Scan][Index]));
  299.                         PRNGCHK(State->OutputScalingFactorLFO,
  300.                             &(State->OutputScalingFactorLFO[Scan]),
  301.                             sizeof(State->OutputScalingFactorLFO[Scan]));
  302.                         PRNGCHK(State->OutputScalingFactorLFO[Scan],
  303.                             &(State->OutputScalingFactorLFO[Scan][Index]),
  304.                             sizeof(State->OutputScalingFactorLFO[Scan][Index]));
  305.                         PRNGCHK(State->OutputScalingFactorEnvelope,
  306.                             &(State->OutputScalingFactorEnvelope[Scan]),
  307.                             sizeof(State->OutputScalingFactorEnvelope[Scan]));
  308.                         PRNGCHK(State->OutputScalingFactorEnvelope[Scan],
  309.                             &(State->OutputScalingFactorEnvelope[Scan][Index]),
  310.                             sizeof(State->OutputScalingFactorEnvelope[Scan][Index]));
  311.                         State->OutputModulationScaling[Scan][Index]
  312.                             = FastFixed2Float(LFOGenUpdateCycle(
  313.                                 State->OutputScalingFactorLFO[Scan][Index],
  314.                                 EnvelopeUpdate(State->OutputScalingFactorEnvelope[Scan][Index])));
  315.                         PRNGCHK(State->OutputModulationOrigin,
  316.                             &(State->OutputModulationOrigin[Scan]),
  317.                             sizeof(State->OutputModulationOrigin[Scan]));
  318.                         PRNGCHK(State->OutputModulationOrigin[Scan],
  319.                             &(State->OutputModulationOrigin[Scan][Index]),
  320.                             sizeof(State->OutputModulationOrigin[Scan][Index]));
  321.                         PRNGCHK(State->OutputOriginAdjustLFO,
  322.                             &(State->OutputOriginAdjustLFO[Scan]),
  323.                             sizeof(State->OutputOriginAdjustLFO[Scan]));
  324.                         PRNGCHK(State->OutputOriginAdjustLFO[Scan],
  325.                             &(State->OutputOriginAdjustLFO[Scan][Index]),
  326.                             sizeof(State->OutputOriginAdjustLFO[Scan][Index]));
  327.                         PRNGCHK(State->OutputOriginAdjustEnvelope,
  328.                             &(State->OutputOriginAdjustEnvelope[Scan]),
  329.                             sizeof(State->OutputOriginAdjustEnvelope[Scan]));
  330.                         PRNGCHK(State->OutputOriginAdjustEnvelope[Scan],
  331.                             &(State->OutputOriginAdjustEnvelope[Scan][Index]),
  332.                             sizeof(State->OutputOriginAdjustEnvelope[Scan][Index]));
  333.                         State->OutputModulationOrigin[Scan][Index]
  334.                             = FastFixed2Float(LFOGenUpdateCycle(
  335.                                 State->OutputOriginAdjustLFO[Scan][Index],
  336.                                 EnvelopeUpdate(State->OutputOriginAdjustEnvelope[Scan][Index])));
  337.                     }
  338.             }
  339.     }
  340.  
  341.  
  342. /* dispose of the modulation oscillator state record */
  343. void                                    DisposeModOscState(ModOscStateRec* State)
  344.     {
  345.         long                                Scan;
  346.  
  347.         CheckPtrExistence(State);
  348.         ValidateState(State);
  349.  
  350.         for (Scan = 0; Scan < State->Template.NumberOfOscillators; Scan += 1)
  351.             {
  352.                 long                                Index;
  353.  
  354.                 PRNGCHK(State->StateArray,&(State->StateArray[Scan]),
  355.                     sizeof(State->StateArray[Scan]));
  356.                 ERROR((State->StateArray[Scan].OscillatorType != eOscillatorSampled)
  357.                     && (State->StateArray[Scan].OscillatorType != eOscillatorWaveTable),
  358.                     PRERR(ForceAbort,"DisposeModOscState:  bad oscillator type"));
  359.                 if (State->StateArray[Scan].OscillatorType == eOscillatorSampled)
  360.                     {
  361.                         DisposeSampleState(State->StateArray[Scan].u.SampleState);
  362.                     }
  363.                  else
  364.                     {
  365.                         DisposeWaveTableState(State->StateArray[Scan].u.WaveTableState);
  366.                     }
  367.                 for (Index = 0; Index < State->Template.PhaseGenNumElements[Scan]; Index += 1)
  368.                     {
  369.                         DisposeEnvelopeStateRecord(State->PhaseGenScalingFactorEnvelope[Scan][Index]);
  370.                         DisposeEnvelopeStateRecord(State->PhaseGenOriginAdjustEnvelope[Scan][Index]);
  371.                         DisposeLFOGenerator(State->PhaseGenScalingFactorLFO[Scan][Index]);
  372.                         DisposeLFOGenerator(State->PhaseGenOriginAdjustLFO[Scan][Index]);
  373.                     }
  374.                 for (Index = 0; Index < State->Template.OutputNumElements[Scan]; Index += 1)
  375.                     {
  376.                         DisposeEnvelopeStateRecord(State->OutputScalingFactorEnvelope[Scan][Index]);
  377.                         DisposeEnvelopeStateRecord(State->OutputOriginAdjustEnvelope[Scan][Index]);
  378.                         DisposeLFOGenerator(State->OutputScalingFactorLFO[Scan][Index]);
  379.                         DisposeLFOGenerator(State->OutputOriginAdjustLFO[Scan][Index]);
  380.                     }
  381.                 ReleasePtr((char*)State->PhaseGenModulationScaling[Scan]);
  382.                 ReleasePtr((char*)State->PhaseGenModulationOrigin[Scan]);
  383.                 ReleasePtr((char*)State->OutputModulationScaling[Scan]);
  384.                 ReleasePtr((char*)State->OutputModulationOrigin[Scan]);
  385.                 ReleasePtr((char*)State->PhaseGenScalingFactorEnvelope[Scan]);
  386.                 ReleasePtr((char*)State->PhaseGenScalingFactorLFO[Scan]);
  387.                 ReleasePtr((char*)State->PhaseGenOriginAdjustEnvelope[Scan]);
  388.                 ReleasePtr((char*)State->PhaseGenOriginAdjustLFO[Scan]);
  389.                 ReleasePtr((char*)State->OutputScalingFactorEnvelope[Scan]);
  390.                 ReleasePtr((char*)State->OutputScalingFactorLFO[Scan]);
  391.                 ReleasePtr((char*)State->OutputOriginAdjustEnvelope[Scan]);
  392.                 ReleasePtr((char*)State->OutputOriginAdjustLFO[Scan]);
  393.             }
  394.         ReleasePtr((char*)State->StateArray);
  395.         ReleasePtr((char*)State->PhaseGenModulationScaling);
  396.         ReleasePtr((char*)State->PhaseGenModulationOrigin);
  397.         ReleasePtr((char*)State->PhaseGenScalingFactorEnvelope);
  398.         ReleasePtr((char*)State->PhaseGenScalingFactorLFO);
  399.         ReleasePtr((char*)State->PhaseGenOriginAdjustEnvelope);
  400.         ReleasePtr((char*)State->PhaseGenOriginAdjustLFO);
  401.         ReleasePtr((char*)State->OutputModulationScaling);
  402.         ReleasePtr((char*)State->OutputModulationOrigin);
  403.         ReleasePtr((char*)State->OutputScalingFactorEnvelope);
  404.         ReleasePtr((char*)State->OutputScalingFactorLFO);
  405.         ReleasePtr((char*)State->OutputOriginAdjustEnvelope);
  406.         ReleasePtr((char*)State->OutputOriginAdjustLFO);
  407.  
  408.         ReleasePtr((char*)State->OldValues);
  409.         ReleasePtr((char*)State->BuildOldValues);
  410.  
  411.         State->Next = StateFreeList;
  412.         StateFreeList = State;
  413.     }
  414.  
  415.  
  416. /* dispose of the modulation oscillator information template */
  417. void                                    DisposeModOscTemplate(ModOscTemplateRec* Template)
  418.     {
  419.         long                                Scan;
  420.  
  421.         CheckPtrExistence(Template);
  422.         ValidateTemplate(Template);
  423.  
  424.         for (Scan = 0; Scan < Template->NumberOfOscillators; Scan += 1)
  425.             {
  426.                 PRNGCHK(Template->TemplateArray,&(Template->TemplateArray[Scan]),
  427.                     sizeof(Template->TemplateArray[Scan]));
  428.                 ERROR((Template->TemplateArray[Scan].OscillatorType != eOscillatorSampled)
  429.                     && (Template->TemplateArray[Scan].OscillatorType != eOscillatorWaveTable),
  430.                     PRERR(ForceAbort,"DisposeModOscTemplate:  bad oscillator type"));
  431.                 if (Template->TemplateArray[Scan].OscillatorType == eOscillatorSampled)
  432.                     {
  433.                         DisposeSampleTemplate(Template->TemplateArray[Scan].u.SampleTemplate);
  434.                     }
  435.                  else
  436.                     {
  437.                         DisposeWaveTableTemplate(Template->TemplateArray[Scan].u.WaveTableTemplate);
  438.                     }
  439.             }
  440.         ReleasePtr((char*)Template->TemplateArray);
  441.  
  442.         for (Scan = 0; Scan < Template->NumberOfOscillators; Scan += 1)
  443.             {
  444.                 PRNGCHK(Template->PhaseGenModulateHow,&(Template->PhaseGenModulateHow[Scan]),
  445.                     sizeof(Template->PhaseGenModulateHow[Scan]));
  446.                 ReleasePtr((char*)(Template->PhaseGenModulateHow[Scan]));
  447.                 PRNGCHK(Template->PhaseGenScalingFactorEnvelope,
  448.                     &(Template->PhaseGenScalingFactorEnvelope[Scan]),
  449.                     sizeof(Template->PhaseGenScalingFactorEnvelope[Scan]));
  450.                 ReleasePtr((char*)(Template->PhaseGenScalingFactorEnvelope[Scan]));
  451.                 PRNGCHK(Template->PhaseGenScalingFactorLFOList,
  452.                     &(Template->PhaseGenScalingFactorLFOList[Scan]),
  453.                     sizeof(Template->PhaseGenScalingFactorLFOList[Scan]));
  454.                 ReleasePtr((char*)(Template->PhaseGenScalingFactorLFOList[Scan]));
  455.                 PRNGCHK(Template->PhaseGenOriginAdjustEnvelope,
  456.                     &(Template->PhaseGenOriginAdjustEnvelope[Scan]),
  457.                     sizeof(Template->PhaseGenOriginAdjustEnvelope[Scan]));
  458.                 ReleasePtr((char*)(Template->PhaseGenOriginAdjustEnvelope[Scan]));
  459.                 PRNGCHK(Template->PhaseGenOriginAdjustLFOList,
  460.                     &(Template->PhaseGenOriginAdjustLFOList[Scan]),
  461.                     sizeof(Template->PhaseGenOriginAdjustLFOList[Scan]));
  462.                 ReleasePtr((char*)(Template->PhaseGenOriginAdjustLFOList[Scan]));
  463.                 PRNGCHK(Template->OutputModulateHow,&(Template->OutputModulateHow[Scan]),
  464.                     sizeof(Template->OutputModulateHow[Scan]));
  465.                 ReleasePtr((char*)(Template->OutputModulateHow[Scan]));
  466.                 PRNGCHK(Template->OutputScalingFactorEnvelope,&(Template->OutputScalingFactorEnvelope[
  467.                     Scan]),sizeof(Template->OutputScalingFactorEnvelope[Scan]));
  468.                 ReleasePtr((char*)(Template->OutputScalingFactorEnvelope[Scan]));
  469.                 PRNGCHK(Template->OutputScalingFactorLFOList,&(Template->OutputScalingFactorLFOList[
  470.                     Scan]),sizeof(Template->OutputScalingFactorLFOList[Scan]));
  471.                 ReleasePtr((char*)(Template->OutputScalingFactorLFOList[Scan]));
  472.                 PRNGCHK(Template->OutputOriginAdjustEnvelope,&(Template->OutputOriginAdjustEnvelope[
  473.                     Scan]),sizeof(Template->OutputOriginAdjustEnvelope[Scan]));
  474.                 ReleasePtr((char*)(Template->OutputOriginAdjustEnvelope[Scan]));
  475.                 PRNGCHK(Template->OutputOriginAdjustLFOList,&(Template->OutputOriginAdjustLFOList[
  476.                     Scan]),sizeof(Template->OutputOriginAdjustLFOList[Scan]));
  477.                 ReleasePtr((char*)(Template->OutputOriginAdjustLFOList[Scan]));
  478.                 PRNGCHK(Template->PhaseGenIndirectionTable,&(Template->PhaseGenIndirectionTable[
  479.                     Scan]),sizeof(Template->PhaseGenIndirectionTable[Scan]));
  480.                 ReleasePtr((char*)(Template->PhaseGenIndirectionTable[Scan]));
  481.                 PRNGCHK(Template->OutputIndirectionTable,&(Template->OutputIndirectionTable[
  482.                     Scan]),sizeof(Template->OutputIndirectionTable[Scan]));
  483.                 ReleasePtr((char*)(Template->OutputIndirectionTable[Scan]));
  484.             }
  485.         ReleasePtr((char*)(Template->PhaseGenModulateHow));
  486.         ReleasePtr((char*)(Template->PhaseGenScalingFactorEnvelope));
  487.         ReleasePtr((char*)(Template->PhaseGenScalingFactorLFOList));
  488.         ReleasePtr((char*)(Template->PhaseGenOriginAdjustEnvelope));
  489.         ReleasePtr((char*)(Template->PhaseGenOriginAdjustLFOList));
  490.         ReleasePtr((char*)(Template->OutputModulateHow));
  491.         ReleasePtr((char*)(Template->OutputScalingFactorEnvelope));
  492.         ReleasePtr((char*)(Template->OutputScalingFactorLFOList));
  493.         ReleasePtr((char*)(Template->OutputOriginAdjustEnvelope));
  494.         ReleasePtr((char*)(Template->OutputOriginAdjustLFOList));
  495.         ReleasePtr((char*)Template->PhaseGenNumElements);
  496.         ReleasePtr((char*)Template->OutputNumElements);
  497.         ReleasePtr((char*)Template->PhaseGenIndirectionTable);
  498.         ReleasePtr((char*)Template->OutputIndirectionTable);
  499.  
  500.         Template->Next = TemplateFreeList;
  501.         TemplateFreeList = Template;
  502.     }
  503.  
  504.  
  505. /* create a new modulation oscillator template */
  506. ModOscTemplateRec*        NewModOscTemplate(struct ArrayRec* OscillatorList,
  507.                                                 float EnvelopeTicksPerSecond, long SamplingRate,
  508.                                                 MyBoolean Stereo, MyBoolean TimeInterp, MyBoolean WaveInterp,
  509.                                                 ErrorDaemonRec* ErrorDaemon)
  510.     {
  511.         ModOscTemplateRec*    Template;
  512.         long                                Scan;
  513.         long                                Limit;
  514.  
  515.         CheckPtrExistence(ErrorDaemon);
  516.         CheckPtrExistence(OscillatorList);
  517.         ERROR(ArrayGetLength(OscillatorList) == 0,PRERR(ForceAbort,
  518.             "NewModOscTemplate:  oscillator list is empty"));
  519.  
  520.         if (TemplateFreeList != NIL)
  521.             {
  522.                 Template = TemplateFreeList;
  523.                 TemplateFreeList = TemplateFreeList->Next;
  524.             }
  525.          else
  526.             {
  527.                 Template = (ModOscTemplateRec*)AllocPtrCanFail(sizeof(ModOscTemplateRec),
  528.                     "ModOscTemplateRec");
  529.                 if (Template == NIL)
  530.                     {
  531.                         return NIL;
  532.                     }
  533.             }
  534.         EXECUTE(Template->Next = (ModOscTemplateRec*)0x81818181;)
  535.  
  536.         Template->NumberOfOscillators = ArrayGetLength(OscillatorList);
  537.  
  538.         Template->StereoPlayback = Stereo;
  539.         Template->TicksPerSecond = EnvelopeTicksPerSecond;
  540.  
  541.         Template->TemplateArray = (TemplateElemRec*)AllocPtrCanFail(sizeof(TemplateElemRec)
  542.             * Template->NumberOfOscillators,"TemplateElemRec[]");
  543.         if (Template->TemplateArray == NIL)
  544.             {
  545.              FailurePoint1:
  546.                 Template->Next = TemplateFreeList;
  547.                 TemplateFreeList = Template;
  548.                 return NIL;
  549.             }
  550.         Template->PhaseGenNumElements = (long*)AllocPtrCanFail(sizeof(long)
  551.             * Template->NumberOfOscillators,"PhaseGenNumElements[]");
  552.         if (Template->PhaseGenNumElements == NIL)
  553.             {
  554.              FailurePoint2:
  555.                 ReleasePtr((char*)Template->TemplateArray);
  556.                 goto FailurePoint1;
  557.             }
  558.         Template->PhaseGenModulateHow = (ModulationTypes**)AllocPtrCanFail(
  559.             sizeof(ModulationTypes*) * Template->NumberOfOscillators,
  560.             "PhaseGenModulateHow[][]");
  561.         if (Template->PhaseGenModulateHow == NIL)
  562.             {
  563.              FailurePoint3:
  564.                 ReleasePtr((char*)Template->PhaseGenNumElements);
  565.                 goto FailurePoint2;
  566.             }
  567.         Template->PhaseGenScalingFactorEnvelope = (EnvelopeRec***)AllocPtrCanFail(
  568.             sizeof(EnvelopeRec**) * Template->NumberOfOscillators,
  569.             "PhaseGenScalingFactorEnvelope[][]");
  570.         if (Template->PhaseGenScalingFactorEnvelope == NIL)
  571.             {
  572.              FailurePoint4:
  573.                 ReleasePtr((char*)Template->PhaseGenModulateHow);
  574.                 goto FailurePoint3;
  575.             }
  576.         Template->PhaseGenScalingFactorLFOList = (LFOListSpecRec***)AllocPtrCanFail(
  577.             sizeof(LFOListSpecRec**) * Template->NumberOfOscillators,
  578.             "PhaseGenScalingFactorLFOList[][]");
  579.         if (Template->PhaseGenScalingFactorLFOList == NIL)
  580.             {
  581.              FailurePoint5:
  582.                 ReleasePtr((char*)Template->PhaseGenScalingFactorEnvelope);
  583.                 goto FailurePoint4;
  584.             }
  585.         Template->PhaseGenOriginAdjustEnvelope = (EnvelopeRec***)AllocPtrCanFail(
  586.             sizeof(EnvelopeRec**) * Template->NumberOfOscillators,
  587.             "PhaseGenOriginAdjustEnvelope[][]");
  588.         if (Template->PhaseGenOriginAdjustEnvelope == NIL)
  589.             {
  590.              FailurePoint6:
  591.                 ReleasePtr((char*)Template->PhaseGenScalingFactorLFOList);
  592.                 goto FailurePoint5;
  593.             }
  594.         Template->PhaseGenOriginAdjustLFOList = (LFOListSpecRec***)AllocPtrCanFail(
  595.             sizeof(LFOListSpecRec**) * Template->NumberOfOscillators,
  596.             "PhaseGenOriginAdjustLFOList[][]");
  597.         if (Template->PhaseGenOriginAdjustLFOList == NIL)
  598.             {
  599.              FailurePoint7:
  600.                 ReleasePtr((char*)Template->PhaseGenOriginAdjustEnvelope);
  601.                 goto FailurePoint6;
  602.             }
  603.         Template->OutputNumElements = (long*)AllocPtrCanFail(sizeof(long)
  604.             * Template->NumberOfOscillators,"OutputNumElements[]");
  605.         if (Template->OutputNumElements == NIL)
  606.             {
  607.              FailurePoint8:
  608.                 ReleasePtr((char*)Template->PhaseGenOriginAdjustLFOList);
  609.                 goto FailurePoint7;
  610.             }
  611.         Template->OutputModulateHow = (ModulationTypes**)AllocPtrCanFail(
  612.             sizeof(ModulationTypes*) * Template->NumberOfOscillators,"OutputModulateHow[][]");
  613.         if (Template->OutputModulateHow == NIL)
  614.             {
  615.              FailurePoint9:
  616.                 ReleasePtr((char*)Template->OutputNumElements);
  617.                 goto FailurePoint8;
  618.             }
  619.         Template->OutputScalingFactorEnvelope = (EnvelopeRec***)AllocPtrCanFail(
  620.             sizeof(EnvelopeRec**) * Template->NumberOfOscillators,
  621.             "OutputScalingFactorEnvelope[][]");
  622.         if (Template->OutputScalingFactorEnvelope == NIL)
  623.             {
  624.              FailurePoint10:
  625.                 ReleasePtr((char*)Template->OutputModulateHow);
  626.                 goto FailurePoint9;
  627.             }
  628.         Template->OutputScalingFactorLFOList = (LFOListSpecRec***)AllocPtrCanFail(
  629.             sizeof(LFOListSpecRec**) * Template->NumberOfOscillators,
  630.             "OutputScalingFactorLFOList[][]");
  631.         if (Template->OutputScalingFactorLFOList == NIL)
  632.             {
  633.              FailurePoint11:
  634.                 ReleasePtr((char*)Template->OutputScalingFactorEnvelope);
  635.                 goto FailurePoint10;
  636.             }
  637.         Template->OutputOriginAdjustEnvelope = (EnvelopeRec***)AllocPtrCanFail(
  638.             sizeof(EnvelopeRec**) * Template->NumberOfOscillators,
  639.             "OutputOriginAdjustEnvelope[][]");
  640.         if (Template->OutputOriginAdjustEnvelope == NIL)
  641.             {
  642.              FailurePoint12:
  643.                 ReleasePtr((char*)Template->OutputScalingFactorLFOList);
  644.                 goto FailurePoint11;
  645.             }
  646.         Template->OutputOriginAdjustLFOList = (LFOListSpecRec***)AllocPtrCanFail(
  647.             sizeof(LFOListSpecRec**) * Template->NumberOfOscillators,
  648.             "OutputOriginAdjustLFOList[][]");
  649.         if (Template->OutputOriginAdjustLFOList == NIL)
  650.             {
  651.              FailurePoint13:
  652.                 ReleasePtr((char*)Template->OutputOriginAdjustEnvelope);
  653.                 goto FailurePoint12;
  654.             }
  655.         Template->PhaseGenIndirectionTable = (long**)AllocPtrCanFail(sizeof(long*)
  656.             * Template->NumberOfOscillators,"PhaseGenIndirectionTable[][]");
  657.         if (Template->PhaseGenIndirectionTable == NIL)
  658.             {
  659.              FailurePoint14:
  660.                 ReleasePtr((char*)Template->OutputOriginAdjustLFOList);
  661.                 goto FailurePoint13;
  662.             }
  663.         Template->OutputIndirectionTable = (long**)AllocPtrCanFail(sizeof(long*)
  664.             * Template->NumberOfOscillators,"OutputIndirectionTable[][]");
  665.         if (Template->OutputIndirectionTable == NIL)
  666.             {
  667.              FailurePoint15:
  668.                 ReleasePtr((char*)Template->PhaseGenIndirectionTable);
  669.                 goto FailurePoint14;
  670.             }
  671.  
  672.         Limit = ArrayGetLength(OscillatorList);
  673.         for (Scan = 0; Scan < Limit; Scan += 1)
  674.             {
  675.                 OscillatorRec*            Oscillator;
  676.                 ModulationSpecRec*    ModulationSourceList;
  677.                 long                                Count;
  678.                 long                                Index;
  679.                 long                                TotalNumModulators;
  680.  
  681.                 Oscillator = (OscillatorRec*)ArrayGetElement(OscillatorList,Scan);
  682.                 CheckPtrExistence(Oscillator);
  683.  
  684.                 switch (OscillatorGetWhatKindItIs(Oscillator))
  685.                     {
  686.                         default:
  687.                             EXECUTE(PRERR(ForceAbort,"NewModOscTemplate:  bad oscillator type"));
  688.                             break;
  689.                         case eOscillatorSampled:
  690.                             PRNGCHK(Template->TemplateArray,&(Template->TemplateArray[Scan]),
  691.                                 sizeof(Template->TemplateArray[Scan]));
  692.                             Template->TemplateArray[Scan].OscillatorType = eOscillatorSampled;
  693.                             Template->TemplateArray[Scan].u.SampleTemplate = NewSampleTemplate(
  694.                                 Oscillator,EnvelopeTicksPerSecond,SamplingRate,Stereo,TimeInterp,
  695.                                 WaveInterp,ErrorDaemon);
  696.                             if (Template->TemplateArray[Scan].u.SampleTemplate == NIL)
  697.                                 {
  698.                                  FailurePoint16a:
  699.                                     for (Index = 0; Index < Scan; Index += 1)
  700.                                         {
  701.                                             PRNGCHK(Template->TemplateArray,&(Template->TemplateArray[Index]),
  702.                                                 sizeof(Template->TemplateArray[Index]));
  703.                                             switch (Template->TemplateArray[Index].OscillatorType)
  704.                                                 {
  705.                                                     default:
  706.                                                         EXECUTE(PRERR(ForceAbort,"NewModOscTemplate:  bad oscillator type"));
  707.                                                         break;
  708.                                                     case eOscillatorSampled:
  709.                                                         DisposeSampleTemplate(Template->TemplateArray[Index]
  710.                                                             .u.SampleTemplate);
  711.                                                         break;
  712.                                                     case eOscillatorWaveTable:
  713.                                                         DisposeWaveTableTemplate(Template->TemplateArray[Index]
  714.                                                             .u.WaveTableTemplate);
  715.                                                         break;
  716.                                                 }
  717.                                             PRNGCHK(Template->PhaseGenModulateHow,
  718.                                                 &(Template->PhaseGenModulateHow[Index]),
  719.                                                 sizeof(Template->PhaseGenModulateHow[Index]));
  720.                                             ReleasePtr((char*)(Template->PhaseGenModulateHow[Index]));
  721.                                             PRNGCHK(Template->PhaseGenScalingFactorEnvelope,
  722.                                                 &(Template->PhaseGenScalingFactorEnvelope[Index]),
  723.                                                 sizeof(Template->PhaseGenScalingFactorEnvelope[Index]));
  724.                                             ReleasePtr((char*)(Template->PhaseGenScalingFactorEnvelope[Index]));
  725.                                             PRNGCHK(Template->PhaseGenScalingFactorLFOList,
  726.                                                 &(Template->PhaseGenScalingFactorLFOList[Index]),
  727.                                                 sizeof(Template->PhaseGenScalingFactorLFOList[Index]));
  728.                                             ReleasePtr((char*)(Template->PhaseGenScalingFactorLFOList[Index]));
  729.                                             PRNGCHK(Template->PhaseGenOriginAdjustEnvelope,
  730.                                                 &(Template->PhaseGenOriginAdjustEnvelope[Index]),
  731.                                                 sizeof(Template->PhaseGenOriginAdjustEnvelope[Index]));
  732.                                             ReleasePtr((char*)(Template->PhaseGenOriginAdjustEnvelope[Index]));
  733.                                             PRNGCHK(Template->PhaseGenOriginAdjustLFOList,
  734.                                                 &(Template->PhaseGenOriginAdjustLFOList[Index]),
  735.                                                 sizeof(Template->PhaseGenOriginAdjustLFOList[Index]));
  736.                                             ReleasePtr((char*)(Template->PhaseGenOriginAdjustLFOList[Index]));
  737.                                             PRNGCHK(Template->OutputModulateHow,
  738.                                                 &(Template->OutputModulateHow[Index]),
  739.                                                 sizeof(Template->OutputModulateHow[Index]));
  740.                                             ReleasePtr((char*)(Template->OutputModulateHow[Index]));
  741.                                             PRNGCHK(Template->OutputScalingFactorEnvelope,
  742.                                                 &(Template->OutputScalingFactorEnvelope[Index]),
  743.                                                 sizeof(Template->OutputScalingFactorEnvelope[Index]));
  744.                                             ReleasePtr((char*)(Template->OutputScalingFactorEnvelope[Index]));
  745.                                             PRNGCHK(Template->OutputScalingFactorLFOList,
  746.                                                 &(Template->OutputScalingFactorLFOList[Index]),
  747.                                                 sizeof(Template->OutputScalingFactorLFOList[Index]));
  748.                                             ReleasePtr((char*)(Template->OutputScalingFactorLFOList[Index]));
  749.                                             PRNGCHK(Template->OutputOriginAdjustEnvelope,
  750.                                                 &(Template->OutputOriginAdjustEnvelope[Index]),
  751.                                                 sizeof(Template->OutputOriginAdjustEnvelope[Index]));
  752.                                             ReleasePtr((char*)(Template->OutputOriginAdjustEnvelope[Index]));
  753.                                             PRNGCHK(Template->OutputOriginAdjustLFOList,
  754.                                                 &(Template->OutputOriginAdjustLFOList[Index]),
  755.                                                 sizeof(Template->OutputOriginAdjustLFOList[Index]));
  756.                                             ReleasePtr((char*)(Template->OutputOriginAdjustLFOList[Index]));
  757.                                         }
  758.                                     goto FailurePoint15;
  759.                                 }
  760.                             break;
  761.                         case eOscillatorWaveTable:
  762.                             PRNGCHK(Template->TemplateArray,&(Template->TemplateArray[Scan]),
  763.                                 sizeof(Template->TemplateArray[Scan]));
  764.                             Template->TemplateArray[Scan].OscillatorType = eOscillatorWaveTable;
  765.                             Template->TemplateArray[Scan].u.WaveTableTemplate = NewWaveTableTemplate(
  766.                                 Oscillator,EnvelopeTicksPerSecond,SamplingRate,Stereo,TimeInterp,
  767.                                 WaveInterp,ErrorDaemon);
  768.                             if (Template->TemplateArray[Scan].u.WaveTableTemplate == NIL)
  769.                                 {
  770.                                     goto FailurePoint16a;
  771.                                 }
  772.                             break;
  773.                     }
  774.  
  775.                 ModulationSourceList = OscillatorGetModulatorInputList(Oscillator);
  776.                 TotalNumModulators = GetModulationSpecNumEntries(ModulationSourceList);
  777.  
  778.                 /* count the number of phase generator modulators */
  779.                 Count = 0;
  780.                 for (Index = 0; Index < TotalNumModulators; Index += 1)
  781.                     {
  782.                         switch (GetModulationDestType(ModulationSourceList,Index))
  783.                             {
  784.                                 default:
  785.                                     EXECUTE(PRERR(ForceAbort,
  786.                                         "NewModOscTemplate:  bad modulation target type"));
  787.                                     break;
  788.                                 case eModulatePhaseGen:
  789.                                     Count += 1;
  790.                                     break;
  791.                                 case eModulateOutput:
  792.                                     break;
  793.                             }
  794.                     }
  795.                 PRNGCHK(Template->PhaseGenNumElements,&(Template->PhaseGenNumElements[Scan]),
  796.                     sizeof(Template->PhaseGenNumElements[Scan]));
  797.                 Template->PhaseGenNumElements[Scan] = Count;
  798.  
  799.                 PRNGCHK(Template->PhaseGenModulateHow,&(Template->PhaseGenModulateHow[Scan]),
  800.                     sizeof(Template->PhaseGenModulateHow[Scan]));
  801.                 Template->PhaseGenModulateHow[Scan] = (ModulationTypes*)AllocPtrCanFail(
  802.                     sizeof(ModulationTypes) * Count,"PhaseGenModulateHow[]");
  803.                 if (Template->PhaseGenModulateHow[Scan] == NIL)
  804.                     {
  805.                      FailurePoint16b:
  806.                         PRNGCHK(Template->TemplateArray,&(Template->TemplateArray[Scan]),
  807.                             sizeof(Template->TemplateArray[Scan]));
  808.                         switch (Template->TemplateArray[Scan].OscillatorType)
  809.                             {
  810.                                 default:
  811.                                     EXECUTE(PRERR(ForceAbort,"NewModOscTemplate:  bad oscillator type"));
  812.                                     break;
  813.                                 case eOscillatorSampled:
  814.                                     DisposeSampleTemplate(Template->TemplateArray[Scan].u.SampleTemplate);
  815.                                     break;
  816.                                 case eOscillatorWaveTable:
  817.                                     DisposeWaveTableTemplate(Template->TemplateArray[Scan].u.WaveTableTemplate);
  818.                                     break;
  819.                             }
  820.                         goto FailurePoint16a;
  821.                     }
  822.                 PRNGCHK(Template->PhaseGenScalingFactorEnvelope,
  823.                     &(Template->PhaseGenScalingFactorEnvelope[Scan]),
  824.                     sizeof(Template->PhaseGenScalingFactorEnvelope[Scan]));
  825.                 Template->PhaseGenScalingFactorEnvelope[Scan] = (EnvelopeRec**)AllocPtrCanFail(
  826.                     sizeof(EnvelopeRec*) * Count,"PhaseGenScalingFactorEnvelope[]");
  827.                 if (Template->PhaseGenScalingFactorEnvelope[Scan] == NIL)
  828.                     {
  829.                      FailurePoint16c:
  830.                         ReleasePtr((char*)(Template->PhaseGenModulateHow[Scan]));
  831.                         goto FailurePoint16b;
  832.                     }
  833.                 PRNGCHK(Template->PhaseGenScalingFactorLFOList,
  834.                     &(Template->PhaseGenScalingFactorLFOList[Scan]),
  835.                     sizeof(Template->PhaseGenScalingFactorLFOList[Scan]));
  836.                 Template->PhaseGenScalingFactorLFOList[Scan] = (LFOListSpecRec**)AllocPtrCanFail(
  837.                     sizeof(LFOListSpecRec*) * Count,"PhaseGenScalingFactorLFOList[]");
  838.                 if (Template->PhaseGenScalingFactorLFOList[Scan] == NIL)
  839.                     {
  840.                      FailurePoint16d:
  841.                         ReleasePtr((char*)(Template->PhaseGenScalingFactorEnvelope[Scan]));
  842.                         goto FailurePoint16c;
  843.                     }
  844.                 PRNGCHK(Template->PhaseGenOriginAdjustEnvelope,
  845.                     &(Template->PhaseGenOriginAdjustEnvelope[Scan]),
  846.                         sizeof(Template->PhaseGenOriginAdjustEnvelope[Scan]));
  847.                 Template->PhaseGenOriginAdjustEnvelope[Scan] = (EnvelopeRec**)AllocPtrCanFail(
  848.                     sizeof(EnvelopeRec*) * Count,"PhaseGenOriginAdjustEnvelope[]");
  849.                 if (Template->PhaseGenOriginAdjustEnvelope[Scan] == NIL)
  850.                     {
  851.                      FailurePoint16e:
  852.                         ReleasePtr((char*)(Template->PhaseGenScalingFactorLFOList[Scan]));
  853.                         goto FailurePoint16d;
  854.                     }
  855.                 PRNGCHK(Template->PhaseGenOriginAdjustLFOList,
  856.                     &(Template->PhaseGenOriginAdjustLFOList[Scan]),
  857.                         sizeof(Template->PhaseGenOriginAdjustLFOList[Scan]));
  858.                 Template->PhaseGenOriginAdjustLFOList[Scan] = (LFOListSpecRec**)AllocPtrCanFail(
  859.                     sizeof(LFOListSpecRec*) * Count,"PhaseGenOriginAdjustLFOList[]");
  860.                 if (Template->PhaseGenOriginAdjustLFOList[Scan] == NIL)
  861.                     {
  862.                      FailurePoint16f:
  863.                         ReleasePtr((char*)(Template->PhaseGenOriginAdjustEnvelope[Scan]));
  864.                         goto FailurePoint16e;
  865.                     }
  866.                 PRNGCHK(Template->PhaseGenIndirectionTable,
  867.                     &(Template->PhaseGenIndirectionTable[Scan]),
  868.                     sizeof(Template->PhaseGenIndirectionTable[Scan]));
  869.                 Template->PhaseGenIndirectionTable[Scan] = (long*)AllocPtrCanFail(
  870.                     sizeof(long) * Count,"PhaseGenIndirectionTable[]");
  871.                 if (Template->PhaseGenIndirectionTable[Scan] == NIL)
  872.                     {
  873.                      FailurePoint16g:
  874.                         ReleasePtr((char*)Template->PhaseGenOriginAdjustLFOList[Scan]);
  875.                         goto FailurePoint16f;
  876.                     }
  877.  
  878.                 /* build phase generator modulation structures */
  879.                 Count = 0;
  880.                 for (Index = 0; Index < TotalNumModulators; Index += 1)
  881.                     {
  882.                         long                                Position;
  883.  
  884.                         switch (GetModulationDestType(ModulationSourceList,Index))
  885.                             {
  886.                                 default:
  887.                                     EXECUTE(PRERR(ForceAbort,
  888.                                         "NewModOscTemplate:  bad modulation target type"));
  889.                                     break;
  890.                                 case eModulatePhaseGen:
  891.                                     PRNGCHK(Template->PhaseGenModulateHow,
  892.                                         &(Template->PhaseGenModulateHow[Scan]),
  893.                                         sizeof(Template->PhaseGenModulateHow[Scan]));
  894.                                     PRNGCHK(Template->PhaseGenModulateHow[Scan],
  895.                                         &(Template->PhaseGenModulateHow[Scan][Count]),
  896.                                         sizeof(Template->PhaseGenModulateHow[Scan][Count]));
  897.                                     Template->PhaseGenModulateHow[Scan][Count] = GetModulationOpType(
  898.                                         ModulationSourceList,Index);
  899.                                     PRNGCHK(Template->PhaseGenScalingFactorEnvelope,
  900.                                         &(Template->PhaseGenScalingFactorEnvelope[Scan]),
  901.                                         sizeof(Template->PhaseGenScalingFactorEnvelope[Scan]));
  902.                                     PRNGCHK(Template->PhaseGenScalingFactorEnvelope[Scan],
  903.                                         &(Template->PhaseGenScalingFactorEnvelope[Scan][Count]),
  904.                                         sizeof(Template->PhaseGenScalingFactorEnvelope[Scan][Count]));
  905.                                     Template->PhaseGenScalingFactorEnvelope[Scan][Count]
  906.                                         = GetModulationScalingFactorEnvelope(ModulationSourceList,Index);
  907.                                     PRNGCHK(Template->PhaseGenScalingFactorLFOList,
  908.                                         &(Template->PhaseGenScalingFactorLFOList[Scan]),
  909.                                         sizeof(Template->PhaseGenScalingFactorLFOList[Scan]));
  910.                                     PRNGCHK(Template->PhaseGenScalingFactorLFOList[Scan],
  911.                                         &(Template->PhaseGenScalingFactorLFOList[Scan][Count]),
  912.                                         sizeof(Template->PhaseGenScalingFactorLFOList[Scan][Count]));
  913.                                     Template->PhaseGenScalingFactorLFOList[Scan][Count]
  914.                                         = GetModulationScalingFactorLFOList(ModulationSourceList,Index);
  915.                                     PRNGCHK(Template->PhaseGenOriginAdjustEnvelope,
  916.                                         &(Template->PhaseGenOriginAdjustEnvelope[Scan]),
  917.                                         sizeof(Template->PhaseGenOriginAdjustEnvelope[Scan]));
  918.                                     PRNGCHK(Template->PhaseGenOriginAdjustEnvelope[Scan],
  919.                                         &(Template->PhaseGenOriginAdjustEnvelope[Scan][Count]),
  920.                                         sizeof(Template->PhaseGenOriginAdjustEnvelope[Scan][Count]));
  921.                                     Template->PhaseGenOriginAdjustEnvelope[Scan][Count]
  922.                                         = GetModulationOriginAdjustEnvelope(ModulationSourceList,Index);
  923.                                     PRNGCHK(Template->PhaseGenOriginAdjustLFOList,
  924.                                         &(Template->PhaseGenOriginAdjustLFOList[Scan]),
  925.                                         sizeof(Template->PhaseGenOriginAdjustLFOList[Scan]));
  926.                                     PRNGCHK(Template->PhaseGenOriginAdjustLFOList[Scan],
  927.                                         &(Template->PhaseGenOriginAdjustLFOList[Scan][Count]),
  928.                                         sizeof(Template->PhaseGenOriginAdjustLFOList[Scan][Count]));
  929.                                     Template->PhaseGenOriginAdjustLFOList[Scan][Count]
  930.                                         = GetModulationOriginAdjustLFOList(ModulationSourceList,Index);
  931.                                     Position = ArrayFindElement(OscillatorList,
  932.                                         GetModulationOscillatorRef(ModulationSourceList,Index));
  933.                                     ERROR(Position == -1,PRERR(ForceAbort,
  934.                                         "NewModOscTemplate:  reference to oscillator not in list"));
  935.                                     PRNGCHK(Template->PhaseGenIndirectionTable,
  936.                                         &(Template->PhaseGenIndirectionTable[Scan]),
  937.                                         sizeof(Template->PhaseGenIndirectionTable[Scan]));
  938.                                     PRNGCHK(Template->PhaseGenIndirectionTable[Scan],
  939.                                         &(Template->PhaseGenIndirectionTable[Scan][Count]),
  940.                                         sizeof(Template->PhaseGenIndirectionTable[Scan][Count]));
  941.                                     Template->PhaseGenIndirectionTable[Scan][Count] = Position;
  942.                                     Count += 1;
  943.                                     break;
  944.                                 case eModulateOutput:
  945.                                     break;
  946.                             }
  947.                     }
  948.  
  949.                 /* count the number of output modulators */
  950.                 Count = 0;
  951.                 for (Index = 0; Index < TotalNumModulators; Index += 1)
  952.                     {
  953.                         switch (GetModulationDestType(ModulationSourceList,Index))
  954.                             {
  955.                                 default:
  956.                                     EXECUTE(PRERR(ForceAbort,
  957.                                         "NewModOscTemplate:  bad modulation target type"));
  958.                                     break;
  959.                                 case eModulatePhaseGen:
  960.                                     break;
  961.                                 case eModulateOutput:
  962.                                     Count += 1;
  963.                                     break;
  964.                             }
  965.                     }
  966.                 PRNGCHK(Template->OutputNumElements,&(Template->OutputNumElements[Scan]),
  967.                     sizeof(Template->OutputNumElements[Scan]));
  968.                 Template->OutputNumElements[Scan] = Count;
  969.  
  970.                 PRNGCHK(Template->OutputModulateHow,&(Template->OutputModulateHow[Scan]),
  971.                     sizeof(Template->OutputModulateHow[Scan]));
  972.                 Template->OutputModulateHow[Scan] = (ModulationTypes*)AllocPtrCanFail(
  973.                     sizeof(ModulationTypes) * Count,"OutputModulateHow[]");
  974.                 if (Template->OutputModulateHow[Scan] == NIL)
  975.                     {
  976.                      FailurePoint16h:
  977.                         ReleasePtr((char*)(Template->PhaseGenIndirectionTable[Scan]));
  978.                         goto FailurePoint16g;
  979.                     }
  980.                 PRNGCHK(Template->OutputScalingFactorEnvelope,
  981.                     &(Template->OutputScalingFactorEnvelope[Scan]),
  982.                     sizeof(Template->OutputScalingFactorEnvelope[Scan]));
  983.                 Template->OutputScalingFactorEnvelope[Scan] = (EnvelopeRec**)AllocPtrCanFail(
  984.                     sizeof(EnvelopeRec*) * Count,"OutputScalingFactorEnvelope[]");
  985.                 if (Template->OutputScalingFactorEnvelope[Scan] == NIL)
  986.                     {
  987.                      FailurePoint16i:
  988.                         ReleasePtr((char*)(Template->OutputModulateHow[Scan]));
  989.                         goto FailurePoint16h;
  990.                     }
  991.                 PRNGCHK(Template->OutputScalingFactorLFOList,
  992.                     &(Template->OutputScalingFactorLFOList[Scan]),
  993.                     sizeof(Template->OutputScalingFactorLFOList[Scan]));
  994.                 Template->OutputScalingFactorLFOList[Scan] = (LFOListSpecRec**)AllocPtrCanFail(
  995.                     sizeof(LFOListSpecRec*) * Count,"OutputScalingFactorLFOList[]");
  996.                 if (Template->OutputScalingFactorLFOList[Scan] == NIL)
  997.                     {
  998.                      FailurePoint16j:
  999.                         ReleasePtr((char*)(Template->OutputScalingFactorEnvelope[Scan]));
  1000.                         goto FailurePoint16i;
  1001.                     }
  1002.                 PRNGCHK(Template->OutputOriginAdjustEnvelope,
  1003.                     &(Template->OutputOriginAdjustEnvelope[Scan]),
  1004.                     sizeof(Template->OutputOriginAdjustEnvelope[Scan]));
  1005.                 Template->OutputOriginAdjustEnvelope[Scan] = (EnvelopeRec**)AllocPtrCanFail(
  1006.                     sizeof(EnvelopeRec*) * Count,"OutputOriginAdjustEnvelope[]");
  1007.                 if (Template->OutputOriginAdjustEnvelope[Scan] == NIL)
  1008.                     {
  1009.                      FailurePoint16k:
  1010.                         ReleasePtr((char*)(Template->OutputScalingFactorLFOList[Scan]));
  1011.                         goto FailurePoint16j;
  1012.                     }
  1013.                 PRNGCHK(Template->OutputOriginAdjustLFOList,
  1014.                     &(Template->OutputOriginAdjustLFOList[Scan]),
  1015.                     sizeof(Template->OutputOriginAdjustLFOList[Scan]));
  1016.                 Template->OutputOriginAdjustLFOList[Scan] = (LFOListSpecRec**)AllocPtrCanFail(
  1017.                     sizeof(LFOListSpecRec*) * Count,"OutputOriginAdjustLFOList[]");
  1018.                 if (Template->OutputOriginAdjustLFOList[Scan] == NIL)
  1019.                     {
  1020.                      FailurePoint16l:
  1021.                         ReleasePtr((char*)(Template->OutputOriginAdjustEnvelope[Scan]));
  1022.                         goto FailurePoint16k;
  1023.                     }
  1024.  
  1025.                 PRNGCHK(Template->OutputIndirectionTable,
  1026.                     &(Template->OutputIndirectionTable[Scan]),
  1027.                     sizeof(Template->OutputIndirectionTable[Scan]));
  1028.                 Template->OutputIndirectionTable[Scan] = (long*)AllocPtrCanFail(
  1029.                     sizeof(long) * Count,"OutputIndirectionTable[]");
  1030.                 if (Template->OutputIndirectionTable[Scan] == NIL)
  1031.                     {
  1032.                      FailurePoint16m:
  1033.                         ReleasePtr((char*)(Template->OutputOriginAdjustLFOList[Scan]));
  1034.                         goto FailurePoint16l;
  1035.                     }
  1036.  
  1037.                 /* build output modulation structures */
  1038.                 Count = 0;
  1039.                 for (Index = 0; Index < TotalNumModulators; Index += 1)
  1040.                     {
  1041.                         long                                Position;
  1042.  
  1043.                         switch (GetModulationDestType(ModulationSourceList,Index))
  1044.                             {
  1045.                                 default:
  1046.                                     EXECUTE(PRERR(ForceAbort,
  1047.                                         "NewModOscTemplate:  bad modulation target type"));
  1048.                                     break;
  1049.                                 case eModulatePhaseGen:
  1050.                                     break;
  1051.                                 case eModulateOutput:
  1052.                                     PRNGCHK(Template->OutputModulateHow,
  1053.                                         &(Template->OutputModulateHow[Scan]),
  1054.                                         sizeof(Template->OutputModulateHow[Scan]));
  1055.                                     PRNGCHK(Template->OutputModulateHow[Scan],
  1056.                                         &(Template->OutputModulateHow[Scan][Count]),
  1057.                                         sizeof(Template->OutputModulateHow[Scan][Count]));
  1058.                                     Template->OutputModulateHow[Scan][Count] = GetModulationOpType(
  1059.                                         ModulationSourceList,Index);
  1060.                                     PRNGCHK(Template->OutputScalingFactorEnvelope,
  1061.                                         &(Template->OutputScalingFactorEnvelope[Scan]),
  1062.                                         sizeof(Template->OutputScalingFactorEnvelope[Scan]));
  1063.                                     PRNGCHK(Template->OutputScalingFactorEnvelope[Scan],
  1064.                                         &(Template->OutputScalingFactorEnvelope[Scan][Count]),
  1065.                                         sizeof(Template->OutputScalingFactorEnvelope[Scan][Count]));
  1066.                                     Template->OutputScalingFactorEnvelope[Scan][Count]
  1067.                                         = GetModulationScalingFactorEnvelope(ModulationSourceList,Index);
  1068.                                     PRNGCHK(Template->OutputScalingFactorLFOList,
  1069.                                         &(Template->OutputScalingFactorLFOList[Scan]),
  1070.                                         sizeof(Template->OutputScalingFactorLFOList[Scan]));
  1071.                                     PRNGCHK(Template->OutputScalingFactorLFOList[Scan],
  1072.                                         &(Template->OutputScalingFactorLFOList[Scan][Count]),
  1073.                                         sizeof(Template->OutputScalingFactorLFOList[Scan][Count]));
  1074.                                     Template->OutputScalingFactorLFOList[Scan][Count]
  1075.                                         = GetModulationScalingFactorLFOList(ModulationSourceList,Index);
  1076.                                     PRNGCHK(Template->OutputOriginAdjustEnvelope,
  1077.                                         &(Template->OutputOriginAdjustEnvelope[Scan]),
  1078.                                         sizeof(Template->OutputOriginAdjustEnvelope[Scan]));
  1079.                                     PRNGCHK(Template->OutputOriginAdjustEnvelope[Scan],
  1080.                                         &(Template->OutputOriginAdjustEnvelope[Scan][Count]),
  1081.                                         sizeof(Template->OutputOriginAdjustEnvelope[Scan][Count]));
  1082.                                     Template->OutputOriginAdjustEnvelope[Scan][Count]
  1083.                                         = GetModulationOriginAdjustEnvelope(ModulationSourceList,Index);
  1084.                                     PRNGCHK(Template->OutputOriginAdjustLFOList,
  1085.                                         &(Template->OutputOriginAdjustLFOList[Scan]),
  1086.                                         sizeof(Template->OutputOriginAdjustLFOList[Scan]));
  1087.                                     PRNGCHK(Template->OutputOriginAdjustLFOList[Scan],
  1088.                                         &(Template->OutputOriginAdjustLFOList[Scan][Count]),
  1089.                                         sizeof(Template->OutputOriginAdjustLFOList[Scan][Count]));
  1090.                                     Template->OutputOriginAdjustLFOList[Scan][Count]
  1091.                                         = GetModulationOriginAdjustLFOList(ModulationSourceList,Index);
  1092.                                     Position = ArrayFindElement(OscillatorList,
  1093.                                         GetModulationOscillatorRef(ModulationSourceList,Index));
  1094.                                     ERROR(Position == -1,PRERR(ForceAbort,
  1095.                                         "NewModOscTemplate:  reference to oscillator not in list"));
  1096.                                     PRNGCHK(Template->OutputIndirectionTable,
  1097.                                         &(Template->OutputIndirectionTable[Scan]),
  1098.                                         sizeof(Template->OutputIndirectionTable[Scan]));
  1099.                                     PRNGCHK(Template->OutputIndirectionTable[Scan],
  1100.                                         &(Template->OutputIndirectionTable[Scan][Count]),
  1101.                                         sizeof(Template->OutputIndirectionTable[Scan][Count]));
  1102.                                     Template->OutputIndirectionTable[Scan][Count] = Position;
  1103.                                     Count += 1;
  1104.                                     break;
  1105.                             }
  1106.                     }
  1107.  
  1108.                 PRNGCHK(Template->OutputNumElements,&(Template->OutputNumElements[Scan]),
  1109.                     sizeof(Template->OutputNumElements[Scan]));
  1110.                 PRNGCHK(Template->PhaseGenNumElements,&(Template->PhaseGenNumElements[Scan]),
  1111.                     sizeof(Template->PhaseGenNumElements[Scan]));
  1112.                 ERROR(Template->OutputNumElements[Scan] + Template->PhaseGenNumElements[Scan]
  1113.                     != TotalNumModulators,PRERR(ForceAbort,
  1114.                     "NewModOscTemplate:  modulator count inconsistency"));
  1115.             }
  1116.  
  1117.         return Template;
  1118.     }
  1119.  
  1120.  
  1121. /* create a new modulation oscillator state object. */
  1122. ModOscStateRec*                NewModOscState(ModOscTemplateRec* Template,
  1123.                                                 float FreqForMultisampling, float Accent1, float Accent2,
  1124.                                                 float Accent3, float Accent4, float Loudness, float HurryUp,
  1125.                                                 long* PreOriginTimeOut, float StereoPosition,
  1126.                                                 float InitialFrequency)
  1127.     {
  1128.         long                                Scan;
  1129.         ModOscStateRec*            State;
  1130.         long                                MaxOrigin;
  1131.  
  1132.         CheckPtrExistence(Template);
  1133.         ValidateTemplate(Template);
  1134.  
  1135.         if (StateFreeList != NIL)
  1136.             {
  1137.                 State = StateFreeList;
  1138.                 StateFreeList = StateFreeList->Next;
  1139.             }
  1140.          else
  1141.             {
  1142.                 State = (ModOscStateRec*)AllocPtrCanFail(sizeof(ModOscStateRec),"ModOscStateRec");
  1143.                 if (State == NIL)
  1144.                     {
  1145.                         return NIL;
  1146.                     }
  1147.             }
  1148.         EXECUTE(State->Next = (ModOscStateRec*)0x81818181;)
  1149.  
  1150.         State->StateArray = (StateElemRec*)AllocPtrCanFail(sizeof(StateElemRec)
  1151.             * Template->NumberOfOscillators,"StateArray");
  1152.         if (State->StateArray == NIL)
  1153.             {
  1154.              FailurePoint1:
  1155.                 State->Next = StateFreeList;
  1156.                 StateFreeList = State;
  1157.                 return NIL;
  1158.             }
  1159.         State->OldValues = (float*)AllocPtrCanFail(sizeof(float)
  1160.             * Template->NumberOfOscillators,"OldValues");
  1161.         if (State->OldValues == NIL)
  1162.             {
  1163.              FailurePoint2:
  1164.                 ReleasePtr((char*)State->StateArray);
  1165.                 goto FailurePoint1;
  1166.             }
  1167.         State->BuildOldValues = (float*)AllocPtrCanFail(sizeof(float)
  1168.             * Template->NumberOfOscillators,"BuildOldValues");
  1169.         if (State->BuildOldValues == NIL)
  1170.             {
  1171.              FailurePoint3:
  1172.                 ReleasePtr((char*)State->OldValues);
  1173.                 goto FailurePoint2;
  1174.             }
  1175.         State->PhaseGenModulationScaling = (float**)AllocPtrCanFail(sizeof(float*)
  1176.             * Template->NumberOfOscillators,"PhaseGenModulationScaling[]");
  1177.         if (State->PhaseGenModulationScaling == NIL)
  1178.             {
  1179.              FailurePoint4:
  1180.                 ReleasePtr((char*)State->BuildOldValues);
  1181.                 goto FailurePoint3;
  1182.             }
  1183.         State->PhaseGenModulationOrigin = (float**)AllocPtrCanFail(sizeof(float*)
  1184.             * Template->NumberOfOscillators,"PhaseGenModulationOrigin[]");
  1185.         if (State->PhaseGenModulationOrigin == NIL)
  1186.             {
  1187.              FailurePoint5:
  1188.                 ReleasePtr((char*)State->PhaseGenModulationScaling);
  1189.                 goto FailurePoint4;
  1190.             }
  1191.         State->PhaseGenScalingFactorEnvelope = (EvalEnvelopeRec***)AllocPtrCanFail(
  1192.             sizeof(EvalEnvelopeRec**) * Template->NumberOfOscillators,
  1193.             "PhaseGenScalingFactorEnvelope[]");
  1194.         if (State->PhaseGenScalingFactorEnvelope == NIL)
  1195.             {
  1196.              FailurePoint6:
  1197.                 ReleasePtr((char*)State->PhaseGenModulationOrigin);
  1198.                 goto FailurePoint5;
  1199.             }
  1200.         State->PhaseGenScalingFactorLFO = (LFOGenRec***)AllocPtrCanFail(
  1201.             sizeof(LFOGenRec**) * Template->NumberOfOscillators,"PhaseGenScalingFactorLFO[]");
  1202.         if (State->PhaseGenScalingFactorLFO == NIL)
  1203.             {
  1204.              FailurePoint7:
  1205.                 ReleasePtr((char*)State->PhaseGenScalingFactorEnvelope);
  1206.                 goto FailurePoint6;
  1207.             }
  1208.         State->PhaseGenOriginAdjustEnvelope = (EvalEnvelopeRec***)AllocPtrCanFail(
  1209.             sizeof(EvalEnvelopeRec**) * Template->NumberOfOscillators,
  1210.             "PhaseGenOriginAdjustEnvelope[]");
  1211.         if (State->PhaseGenOriginAdjustEnvelope == NIL)
  1212.             {
  1213.              FailurePoint8:
  1214.                 ReleasePtr((char*)State->PhaseGenScalingFactorLFO);
  1215.                 goto FailurePoint7;
  1216.             }
  1217.         State->PhaseGenOriginAdjustLFO = (LFOGenRec***)AllocPtrCanFail(
  1218.             sizeof(LFOGenRec**) * Template->NumberOfOscillators,"PhaseGenOriginAdjustLFO[]");
  1219.         if (State->PhaseGenOriginAdjustLFO == NIL)
  1220.             {
  1221.              FailurePoint9:
  1222.                 ReleasePtr((char*)State->PhaseGenOriginAdjustEnvelope);
  1223.                 goto FailurePoint8;
  1224.             }
  1225.         State->OutputModulationScaling = (float**)AllocPtrCanFail(sizeof(float*)
  1226.             * Template->NumberOfOscillators,"OutputModulationScaling[]");
  1227.         if (State->OutputModulationScaling == NIL)
  1228.             {
  1229.              FailurePoint10:
  1230.                 ReleasePtr((char*)State->PhaseGenOriginAdjustLFO);
  1231.                 goto FailurePoint9;
  1232.             }
  1233.         State->OutputModulationOrigin = (float**)AllocPtrCanFail(sizeof(float*)
  1234.             * Template->NumberOfOscillators,"OutputModulationOrigin[]");
  1235.         if (State->OutputModulationOrigin == NIL)
  1236.             {
  1237.              FailurePoint11:
  1238.                 ReleasePtr((char*)State->OutputModulationScaling);
  1239.                 goto FailurePoint10;
  1240.             }
  1241.         State->OutputScalingFactorEnvelope = (EvalEnvelopeRec***)AllocPtrCanFail(
  1242.             sizeof(EvalEnvelopeRec**) * Template->NumberOfOscillators,
  1243.             "OutputScalingFactorEnvelope[]");
  1244.         if (State->OutputScalingFactorEnvelope == NIL)
  1245.             {
  1246.              FailurePoint12:
  1247.                 ReleasePtr((char*)State->OutputModulationOrigin);
  1248.                 goto FailurePoint11;
  1249.             }
  1250.         State->OutputScalingFactorLFO = (LFOGenRec***)AllocPtrCanFail(sizeof(LFOGenRec**)
  1251.             * Template->NumberOfOscillators,"OutputScalingFactorLFO[]");
  1252.         if (State->OutputScalingFactorLFO == NIL)
  1253.             {
  1254.              FailurePoint13:
  1255.                 ReleasePtr((char*)State->OutputScalingFactorEnvelope);
  1256.                 goto FailurePoint12;
  1257.             }
  1258.         State->OutputOriginAdjustEnvelope = (EvalEnvelopeRec***)AllocPtrCanFail(
  1259.             sizeof(EvalEnvelopeRec**) * Template->NumberOfOscillators,
  1260.             "OutputOriginAdjustEnvelope[]");
  1261.         if (State->OutputOriginAdjustEnvelope == NIL)
  1262.             {
  1263.              FailurePoint14:
  1264.                 ReleasePtr((char*)State->OutputScalingFactorLFO);
  1265.                 goto FailurePoint13;
  1266.             }
  1267.         State->OutputOriginAdjustLFO = (LFOGenRec***)AllocPtrCanFail(sizeof(LFOGenRec**)
  1268.             * Template->NumberOfOscillators,"OutputOriginAdjustLFO[]");
  1269.         if (State->OutputOriginAdjustLFO == NIL)
  1270.             {
  1271.              FailurePoint15:
  1272.                 ReleasePtr((char*)State->OutputOriginAdjustEnvelope);
  1273.                 goto FailurePoint14;
  1274.             }
  1275.  
  1276.         MaxOrigin = 0;
  1277.         for (Scan = 0; Scan < Template->NumberOfOscillators; Scan += 1)
  1278.             {
  1279.                 long                                TempOrigin;
  1280.                 long                                Index;
  1281.  
  1282.                 PRNGCHK(State->StateArray,&(State->StateArray[Scan]),
  1283.                     sizeof(State->StateArray[Scan]));
  1284.                 PRNGCHK(Template->TemplateArray,&(Template->TemplateArray[Scan]),
  1285.                     sizeof(Template->TemplateArray[Scan]));
  1286.                 State->StateArray[Scan].OscillatorType
  1287.                     = Template->TemplateArray[Scan].OscillatorType;
  1288.                 switch (State->StateArray[Scan].OscillatorType)
  1289.                     {
  1290.                         default:
  1291.                             EXECUTE(PRERR(ForceAbort,"NewModOscState:  bad oscillator type"));
  1292.                             break;
  1293.                         case eOscillatorSampled:
  1294.                             State->StateArray[Scan].u.SampleState = NewSampleState(
  1295.                                 Template->TemplateArray[Scan].u.SampleTemplate,FreqForMultisampling,
  1296.                                 Accent1,Accent2,Accent3,Accent4,Loudness,HurryUp,&TempOrigin,
  1297.                                 StereoPosition,InitialFrequency);
  1298.                             if (State->StateArray[Scan].u.SampleState == NIL)
  1299.                                 {
  1300.                                  FailurePoint16a:
  1301.                                     for (Index = 0; Index < Scan; Index += 1)
  1302.                                         {
  1303.                                             long                                Dumper;
  1304.  
  1305.                                             switch (State->StateArray[Index].OscillatorType)
  1306.                                                 {
  1307.                                                     default:
  1308.                                                         EXECUTE(PRERR(ForceAbort,"NewModOscState:  bad oscillator type"));
  1309.                                                         break;
  1310.                                                     case eOscillatorSampled:
  1311.                                                         DisposeSampleState(State->StateArray[Index].u.SampleState);
  1312.                                                         break;
  1313.                                                     case eOscillatorWaveTable:
  1314.                                                         DisposeWaveTableState(State->StateArray[Index].u.WaveTableState);
  1315.                                                         break;
  1316.                                                 }
  1317.                                             for (Dumper = 0; Dumper < Template->PhaseGenNumElements[Index]; Dumper += 1)
  1318.                                                 {
  1319.                                                     DisposeEnvelopeStateRecord(State->PhaseGenScalingFactorEnvelope[Index][Dumper]);
  1320.                                                     DisposeLFOGenerator(State->PhaseGenScalingFactorLFO[Index][Dumper]);
  1321.                                                     DisposeEnvelopeStateRecord(State->PhaseGenOriginAdjustEnvelope[Index][Dumper]);
  1322.                                                     DisposeLFOGenerator(State->PhaseGenOriginAdjustLFO[Index][Dumper]);
  1323.                                                 }
  1324.                                             for (Dumper = 0; Dumper < Template->OutputNumElements[Index]; Dumper += 1)
  1325.                                                 {
  1326.                                                     DisposeEnvelopeStateRecord(State->OutputScalingFactorEnvelope[Index][Dumper]);
  1327.                                                     DisposeLFOGenerator(State->OutputScalingFactorLFO[Index][Dumper]);
  1328.                                                     DisposeEnvelopeStateRecord(State->OutputOriginAdjustEnvelope[Index][Dumper]);
  1329.                                                     DisposeLFOGenerator(State->OutputOriginAdjustLFO[Index][Dumper]);
  1330.                                                 }
  1331.                                             ReleasePtr((char*)State->PhaseGenModulationScaling[Index]);
  1332.                                             ReleasePtr((char*)State->PhaseGenModulationOrigin[Index]);
  1333.                                             ReleasePtr((char*)State->PhaseGenScalingFactorEnvelope[Index]);
  1334.                                             ReleasePtr((char*)State->PhaseGenScalingFactorLFO[Index]);
  1335.                                             ReleasePtr((char*)State->PhaseGenOriginAdjustEnvelope[Index]);
  1336.                                             ReleasePtr((char*)State->PhaseGenOriginAdjustLFO[Index]);
  1337.                                             ReleasePtr((char*)State->OutputModulationScaling[Index]);
  1338.                                             ReleasePtr((char*)State->OutputModulationOrigin[Index]);
  1339.                                             ReleasePtr((char*)State->OutputScalingFactorEnvelope[Index]);
  1340.                                             ReleasePtr((char*)State->OutputScalingFactorLFO[Index]);
  1341.                                             ReleasePtr((char*)State->OutputOriginAdjustEnvelope[Index]);
  1342.                                             ReleasePtr((char*)State->OutputOriginAdjustLFO);
  1343.                                         }
  1344.                                     ReleasePtr((char*)State->OutputOriginAdjustLFO);
  1345.                                     goto FailurePoint15;
  1346.                                 }
  1347.                             break;
  1348.                         case eOscillatorWaveTable:
  1349.                             State->StateArray[Scan].u.WaveTableState = NewWaveTableState(
  1350.                                 Template->TemplateArray[Scan].u.WaveTableTemplate,FreqForMultisampling,
  1351.                                 Accent1,Accent2,Accent3,Accent4,Loudness,HurryUp,&TempOrigin,
  1352.                                 StereoPosition,InitialFrequency);
  1353.                             if (State->StateArray[Scan].u.WaveTableState == NIL)
  1354.                                 {
  1355.                                     goto FailurePoint16a;
  1356.                                 }
  1357.                             break;
  1358.                     }
  1359.  
  1360.                 if (TempOrigin > MaxOrigin)
  1361.                     {
  1362.                         MaxOrigin = TempOrigin;
  1363.                     }
  1364.  
  1365.                 PRNGCHK(State->OldValues,&(State->OldValues[Scan]),sizeof(State->OldValues[Scan]));
  1366.                 State->OldValues[Scan] = 0;
  1367.  
  1368.                 State->PhaseGenScalingFactorEnvelope[Scan] = (EvalEnvelopeRec**)
  1369.                     AllocPtrCanFail(sizeof(EvalEnvelopeRec*) * Template->PhaseGenNumElements[Scan],
  1370.                     "PhaseGenScalingFactorEnvelope[][]");
  1371.                 if (State->PhaseGenScalingFactorEnvelope[Scan] == NIL)
  1372.                     {
  1373.                      FailurePoint16b:
  1374.                         switch (State->StateArray[Scan].OscillatorType)
  1375.                             {
  1376.                                 default:
  1377.                                     EXECUTE(PRERR(ForceAbort,"NewModOscState:  bad oscillator type"));
  1378.                                     break;
  1379.                                 case eOscillatorSampled:
  1380.                                     DisposeSampleState(State->StateArray[Scan].u.SampleState);
  1381.                                     break;
  1382.                                 case eOscillatorWaveTable:
  1383.                                     DisposeWaveTableState(State->StateArray[Scan].u.WaveTableState);
  1384.                                     break;
  1385.                             }
  1386.                         goto FailurePoint16a;
  1387.                     }
  1388.                 for (Index = 0; Index < Template->PhaseGenNumElements[Scan]; Index += 1)
  1389.                     {
  1390.                         State->PhaseGenScalingFactorEnvelope[Scan][Index] = NewEnvelopeStateRecord(
  1391.                             Template->PhaseGenScalingFactorEnvelope[Scan][Index],Accent1,Accent2,
  1392.                             Accent3,Accent4,InitialFrequency,1,HurryUp,Template->TicksPerSecond,
  1393.                             &TempOrigin);
  1394.                         if (State->PhaseGenScalingFactorEnvelope[Scan][Index] == NIL)
  1395.                             {
  1396.                                 long                                Dumper;
  1397.  
  1398.                              FailurePoint16c:
  1399.                                 for (Dumper = 0; Dumper < Index; Dumper += 1)
  1400.                                     {
  1401.                                         DisposeEnvelopeStateRecord(
  1402.                                             State->PhaseGenScalingFactorEnvelope[Scan][Dumper]);
  1403.                                     }
  1404.                                 ReleasePtr((char*)State->PhaseGenScalingFactorEnvelope[Scan]);
  1405.                                 goto FailurePoint16b;
  1406.                             }
  1407.                         if (TempOrigin > MaxOrigin)
  1408.                             {
  1409.                                 MaxOrigin = TempOrigin;
  1410.                             }
  1411.                     }
  1412.  
  1413.                 State->PhaseGenScalingFactorLFO[Scan] = (LFOGenRec**)AllocPtrCanFail(
  1414.                     sizeof(LFOGenRec*) * Template->PhaseGenNumElements[Scan],
  1415.                     "PhaseGenScalingFactorLFO[][]");
  1416.                 if (State->PhaseGenScalingFactorLFO[Scan] == NIL)
  1417.                     {
  1418.                      FailurePoint16d:
  1419.                         Index = Template->PhaseGenNumElements[Scan]; /* fudge up index for previous */
  1420.                         goto FailurePoint16c;
  1421.                     }
  1422.                 for (Index = 0; Index < Template->PhaseGenNumElements[Scan]; Index += 1)
  1423.                     {
  1424.                         State->PhaseGenScalingFactorLFO[Scan][Index] = NewLFOGenerator(
  1425.                             Template->PhaseGenScalingFactorLFOList[Scan][Index],&TempOrigin,
  1426.                             Accent1,Accent2,Accent3,Accent4,InitialFrequency,HurryUp,
  1427.                             Template->TicksPerSecond,1,1,eLFOArithDefault,FreqForMultisampling);
  1428.                         if (State->PhaseGenScalingFactorLFO[Scan][Index] == NIL)
  1429.                             {
  1430.                                 long                                Dumper;
  1431.  
  1432.                              FailurePoint16e:
  1433.                                 for (Dumper = 0; Dumper < Index; Dumper += 1)
  1434.                                     {
  1435.                                         DisposeLFOGenerator(State->PhaseGenScalingFactorLFO[Scan][Dumper]);
  1436.                                     }
  1437.                                 ReleasePtr((char*)State->PhaseGenScalingFactorLFO[Scan]);
  1438.                                 goto FailurePoint16d;
  1439.                             }
  1440.                         if (TempOrigin > MaxOrigin)
  1441.                             {
  1442.                                 MaxOrigin = TempOrigin;
  1443.                             }
  1444.                     }
  1445.  
  1446.                 State->PhaseGenOriginAdjustEnvelope[Scan] = (EvalEnvelopeRec**)
  1447.                     AllocPtrCanFail(sizeof(EvalEnvelopeRec*) * Template->PhaseGenNumElements[Scan],
  1448.                     "PhaseGenOriginAdjustEnvelope[][]");
  1449.                 if (State->PhaseGenOriginAdjustEnvelope[Scan] == NIL)
  1450.                     {
  1451.                      FailurePoint16f:
  1452.                         Index = Template->PhaseGenNumElements[Scan]; /* fudge up index for previous */
  1453.                         goto FailurePoint16e;
  1454.                     }
  1455.                 for (Index = 0; Index < Template->PhaseGenNumElements[Scan]; Index += 1)
  1456.                     {
  1457.                         State->PhaseGenOriginAdjustEnvelope[Scan][Index] = NewEnvelopeStateRecord(
  1458.                             Template->PhaseGenOriginAdjustEnvelope[Scan][Index],Accent1,Accent2,
  1459.                             Accent3,Accent4,InitialFrequency,1,HurryUp,Template->TicksPerSecond,
  1460.                             &TempOrigin);
  1461.                         if (State->PhaseGenOriginAdjustEnvelope[Scan][Index] == NIL)
  1462.                             {
  1463.                                 long                                Dumper;
  1464.  
  1465.                              FailurePoint16g:
  1466.                                 for (Dumper = 0; Dumper < Index; Dumper += 1)
  1467.                                     {
  1468.                                         DisposeEnvelopeStateRecord(
  1469.                                             State->PhaseGenOriginAdjustEnvelope[Scan][Dumper]);
  1470.                                     }
  1471.                                 ReleasePtr((char*)State->PhaseGenOriginAdjustEnvelope[Scan]);
  1472.                                 goto FailurePoint16f;
  1473.                             }
  1474.                         if (TempOrigin > MaxOrigin)
  1475.                             {
  1476.                                 MaxOrigin = TempOrigin;
  1477.                             }
  1478.                     }
  1479.  
  1480.                 State->PhaseGenOriginAdjustLFO[Scan] = (LFOGenRec**)AllocPtrCanFail(
  1481.                     sizeof(LFOGenRec*) * Template->PhaseGenNumElements[Scan],
  1482.                     "PhaseGenOriginAdjustLFO[][]");
  1483.                 if (State->PhaseGenOriginAdjustLFO[Scan] == NIL)
  1484.                     {
  1485.                      FailurePoint16h:
  1486.                         Index = Template->PhaseGenNumElements[Scan]; /* fudge up index for previous */
  1487.                         goto FailurePoint16g;
  1488.                     }
  1489.                 for (Index = 0; Index < Template->PhaseGenNumElements[Scan]; Index += 1)
  1490.                     {
  1491.                         State->PhaseGenOriginAdjustLFO[Scan][Index] = NewLFOGenerator(
  1492.                             Template->PhaseGenOriginAdjustLFOList[Scan][Index],&TempOrigin,
  1493.                             Accent1,Accent2,Accent3,Accent4,InitialFrequency,HurryUp,
  1494.                             Template->TicksPerSecond,1,1,eLFOArithDefault,FreqForMultisampling);
  1495.                         if (State->PhaseGenOriginAdjustLFO[Scan][Index] == NIL)
  1496.                             {
  1497.                                 long                                Dumper;
  1498.  
  1499.                              FailurePoint16i:
  1500.                                 for (Dumper = 0; Dumper < Index; Dumper += 1)
  1501.                                     {
  1502.                                         DisposeLFOGenerator(State->PhaseGenOriginAdjustLFO[Scan][Dumper]);
  1503.                                     }
  1504.                                 ReleasePtr((char*)State->PhaseGenOriginAdjustLFO[Scan]);
  1505.                                 goto FailurePoint16h;
  1506.                             }
  1507.                         if (TempOrigin > MaxOrigin)
  1508.                             {
  1509.                                 MaxOrigin = TempOrigin;
  1510.                             }
  1511.                     }
  1512.  
  1513.                 State->OutputScalingFactorEnvelope[Scan] = (EvalEnvelopeRec**)
  1514.                     AllocPtrCanFail(sizeof(EvalEnvelopeRec*) * Template->OutputNumElements[Scan],
  1515.                     "OutputScalingFactorEnvelope[][]");
  1516.                 if (State->OutputScalingFactorEnvelope[Scan] == NIL)
  1517.                     {
  1518.                      FailurePoint16j:
  1519.                         Index = Template->PhaseGenNumElements[Scan]; /* fudge up index for previous */
  1520.                         goto FailurePoint16i;
  1521.                     }
  1522.                 for (Index = 0; Index < Template->OutputNumElements[Scan]; Index += 1)
  1523.                     {
  1524.                         State->OutputScalingFactorEnvelope[Scan][Index] = NewEnvelopeStateRecord(
  1525.                             Template->OutputScalingFactorEnvelope[Scan][Index],Accent1,Accent2,
  1526.                             Accent3,Accent4,InitialFrequency,1,HurryUp,Template->TicksPerSecond,
  1527.                             &TempOrigin);
  1528.                         if (State->OutputScalingFactorEnvelope[Scan][Index] == NIL)
  1529.                             {
  1530.                                 long                                Dumper;
  1531.  
  1532.                              FailurePoint16k:
  1533.                                 for (Dumper = 0; Dumper < Index; Dumper += 1)
  1534.                                     {
  1535.                                         DisposeEnvelopeStateRecord(
  1536.                                             State->OutputScalingFactorEnvelope[Scan][Dumper]);
  1537.                                     }
  1538.                                 ReleasePtr((char*)State->OutputScalingFactorEnvelope[Scan]);
  1539.                                 goto FailurePoint16j;
  1540.                             }
  1541.                         if (TempOrigin > MaxOrigin)
  1542.                             {
  1543.                                 MaxOrigin = TempOrigin;
  1544.                             }
  1545.                     }
  1546.  
  1547.                 State->OutputScalingFactorLFO[Scan] = (LFOGenRec**)AllocPtrCanFail(
  1548.                     sizeof(LFOGenRec*) * Template->OutputNumElements[Scan],
  1549.                     "OutputScalingFactorLFO[][]");
  1550.                 if (State->OutputScalingFactorLFO[Scan] == NIL)
  1551.                     {
  1552.                      FailurePoint16l:
  1553.                         Index = Template->OutputNumElements[Scan]; /* fudge up index for previous */
  1554.                         goto FailurePoint16k;
  1555.                     }
  1556.                 for (Index = 0; Index < Template->OutputNumElements[Scan]; Index += 1)
  1557.                     {
  1558.                         State->OutputScalingFactorLFO[Scan][Index] = NewLFOGenerator(
  1559.                             Template->OutputScalingFactorLFOList[Scan][Index],&TempOrigin,
  1560.                             Accent1,Accent2,Accent3,Accent4,InitialFrequency,HurryUp,
  1561.                             Template->TicksPerSecond,1,1,eLFOArithDefault,FreqForMultisampling);
  1562.                         if (State->OutputScalingFactorLFO[Scan][Index] == NIL)
  1563.                             {
  1564.                                 long                                Dumper;
  1565.  
  1566.                              FailurePoint16m:
  1567.                                 for (Dumper = 0; Dumper < Index; Dumper += 1)
  1568.                                     {
  1569.                                         DisposeLFOGenerator(State->OutputScalingFactorLFO[Scan][Dumper]);
  1570.                                     }
  1571.                                 ReleasePtr((char*)State->OutputScalingFactorLFO[Scan]);
  1572.                                 goto FailurePoint16l;
  1573.                             }
  1574.                         if (TempOrigin > MaxOrigin)
  1575.                             {
  1576.                                 MaxOrigin = TempOrigin;
  1577.                             }
  1578.                     }
  1579.  
  1580.                 State->OutputOriginAdjustEnvelope[Scan] = (EvalEnvelopeRec**)
  1581.                     AllocPtrCanFail(sizeof(EvalEnvelopeRec*) * Template->OutputNumElements[Scan],
  1582.                     "OutputOriginAdjustEnvelope[][]");
  1583.                 if (State->OutputOriginAdjustEnvelope[Scan] == NIL)
  1584.                     {
  1585.                      FailurePoint16n:
  1586.                         Index = Template->OutputNumElements[Scan]; /* fudge up index for previous */
  1587.                         goto FailurePoint16m;
  1588.                     }
  1589.                 for (Index = 0; Index < Template->OutputNumElements[Scan]; Index += 1)
  1590.                     {
  1591.                         State->OutputOriginAdjustEnvelope[Scan][Index] = NewEnvelopeStateRecord(
  1592.                             Template->OutputOriginAdjustEnvelope[Scan][Index],Accent1,Accent2,
  1593.                             Accent3,Accent4,InitialFrequency,1,HurryUp,Template->TicksPerSecond,
  1594.                             &TempOrigin);
  1595.                         if (State->OutputOriginAdjustEnvelope[Scan][Index] == NIL)
  1596.                             {
  1597.                                 long                                Dumper;
  1598.  
  1599.                              FailurePoint16o:
  1600.                                 for (Dumper = 0; Dumper < Index; Dumper += 1)
  1601.                                     {
  1602.                                         DisposeEnvelopeStateRecord(
  1603.                                             State->OutputOriginAdjustEnvelope[Scan][Dumper]);
  1604.                                     }
  1605.                                 ReleasePtr((char*)State->OutputOriginAdjustEnvelope[Scan]);
  1606.                                 goto FailurePoint16n;
  1607.                             }
  1608.                         if (TempOrigin > MaxOrigin)
  1609.                             {
  1610.                                 MaxOrigin = TempOrigin;
  1611.                             }
  1612.                     }
  1613.  
  1614.                 State->OutputOriginAdjustLFO[Scan] = (LFOGenRec**)AllocPtrCanFail(
  1615.                     sizeof(LFOGenRec*) * Template->OutputNumElements[Scan],
  1616.                     "OutputOriginAdjustLFO[][]");
  1617.                 if (State->OutputOriginAdjustLFO[Scan] == NIL)
  1618.                     {
  1619.                      FailurePoint16p:
  1620.                         Index = Template->OutputNumElements[Scan]; /* fudge up index for previous */
  1621.                         goto FailurePoint16o;
  1622.                     }
  1623.                 for (Index = 0; Index < Template->OutputNumElements[Scan]; Index += 1)
  1624.                     {
  1625.                         State->OutputOriginAdjustLFO[Scan][Index] = NewLFOGenerator(
  1626.                             Template->OutputOriginAdjustLFOList[Scan][Index],&TempOrigin,
  1627.                             Accent1,Accent2,Accent3,Accent4,InitialFrequency,HurryUp,
  1628.                             Template->TicksPerSecond,1,1,eLFOArithDefault,FreqForMultisampling);
  1629.                         if (State->OutputOriginAdjustLFO[Scan][Index] == NIL)
  1630.                             {
  1631.                                 long                                Dumper;
  1632.  
  1633.                              FailurePoint16q:
  1634.                                 for (Dumper = 0; Dumper < Index; Dumper += 1)
  1635.                                     {
  1636.                                         DisposeLFOGenerator(State->OutputOriginAdjustLFO[Scan][Dumper]);
  1637.                                     }
  1638.                                 ReleasePtr((char*)State->OutputOriginAdjustLFO[Scan]);
  1639.                                 goto FailurePoint16p;
  1640.                             }
  1641.                         if (TempOrigin > MaxOrigin)
  1642.                             {
  1643.                                 MaxOrigin = TempOrigin;
  1644.                             }
  1645.                     }
  1646.  
  1647.                 State->PhaseGenModulationScaling[Scan] = (float*)AllocPtrCanFail(
  1648.                     sizeof(float) * Template->PhaseGenNumElements[Scan],
  1649.                     "PhaseGenModulationScaling[][]");
  1650.                 if (State->PhaseGenModulationScaling[Scan] == NIL)
  1651.                     {
  1652.                      FailurePoint16r:
  1653.                         Index = Template->OutputNumElements[Scan]; /* fudge up index for previous */
  1654.                         goto FailurePoint16q;
  1655.                     }
  1656.  
  1657.                 State->PhaseGenModulationOrigin[Scan] = (float*)AllocPtrCanFail(
  1658.                     sizeof(float) * Template->PhaseGenNumElements[Scan],
  1659.                     "PhaseGenModulationOrigin[][]");
  1660.                 if (State->PhaseGenModulationOrigin[Scan] == NIL)
  1661.                     {
  1662.                      FailurePoint16s:
  1663.                         ReleasePtr((char*)State->PhaseGenModulationScaling[Scan]);
  1664.                         goto FailurePoint16r;
  1665.                     }
  1666.  
  1667.                 State->OutputModulationScaling[Scan] = (float*)AllocPtrCanFail(
  1668.                     sizeof(float) * Template->OutputNumElements[Scan],"OutputModulationScaling[][]");
  1669.                 if (State->OutputModulationScaling[Scan] == NIL)
  1670.                     {
  1671.                      FailurePoint16t:
  1672.                         ReleasePtr((char*)State->PhaseGenModulationOrigin[Scan]);
  1673.                         goto FailurePoint16s;
  1674.                     }
  1675.  
  1676.                 State->OutputModulationOrigin[Scan] = (float*)AllocPtrCanFail(
  1677.                     sizeof(float) * Template->OutputNumElements[Scan],"OutputModulationOrigin[][]");
  1678.                 if (State->OutputModulationOrigin[Scan] == NIL)
  1679.                     {
  1680.                      FailurePoint16u:
  1681.                         ReleasePtr((char*)State->OutputModulationScaling[Scan]);
  1682.                         goto FailurePoint16t;
  1683.                     }
  1684.             }
  1685.  
  1686.         State->Template = *Template;
  1687.         *PreOriginTimeOut = MaxOrigin;
  1688.  
  1689.         return State;
  1690.     }
  1691.  
  1692.  
  1693. /* fix up pre-origin time for the modulation oscillator state object */
  1694. void                                    FixUpModOscStatePreOrigin(ModOscStateRec* State,
  1695.                                                 long ActualPreOrigin)
  1696.     {
  1697.         long                                Scan;
  1698.  
  1699.         CheckPtrExistence(State);
  1700.         ValidateState(State);
  1701.  
  1702.         for (Scan = 0; Scan < State->Template.NumberOfOscillators; Scan += 1)
  1703.             {
  1704.                 long                                Index;
  1705.  
  1706.                 PRNGCHK(State->StateArray,&(State->StateArray[Scan]),
  1707.                     sizeof(State->StateArray[Scan]));
  1708.                 switch (State->StateArray[Scan].OscillatorType)
  1709.                     {
  1710.                         default:
  1711.                             EXECUTE(PRERR(ForceAbort,"FixUpModOscStatePreOrigin:  bad oscillator type"));
  1712.                             break;
  1713.                         case eOscillatorSampled:
  1714.                             FixUpSampleStatePreOrigin(State->StateArray[Scan].u.SampleState,
  1715.                                 ActualPreOrigin);
  1716.                             break;
  1717.                         case eOscillatorWaveTable:
  1718.                             FixUpWaveTableStatePreOrigin(State->StateArray[Scan].u.WaveTableState,
  1719.                                 ActualPreOrigin);
  1720.                             break;
  1721.                     }
  1722.  
  1723.                 for (Index = 0; Index < State->Template.PhaseGenNumElements[Scan]; Index += 1)
  1724.                     {
  1725.                         EnvelopeStateFixUpInitialDelay(State->PhaseGenScalingFactorEnvelope[
  1726.                             Scan][Index],ActualPreOrigin);
  1727.                         LFOGeneratorFixEnvelopeOrigins(State->PhaseGenScalingFactorLFO[Scan][Index],
  1728.                             ActualPreOrigin);
  1729.                         EnvelopeStateFixUpInitialDelay(State->PhaseGenOriginAdjustEnvelope[
  1730.                             Scan][Index],ActualPreOrigin);
  1731.                         LFOGeneratorFixEnvelopeOrigins(State->PhaseGenOriginAdjustLFO[Scan][Index],
  1732.                             ActualPreOrigin);
  1733.                     }
  1734.  
  1735.                 for (Index = 0; Index < State->Template.OutputNumElements[Scan]; Index += 1)
  1736.                     {
  1737.                         EnvelopeStateFixUpInitialDelay(State->OutputScalingFactorEnvelope[
  1738.                             Scan][Index],ActualPreOrigin);
  1739.                         LFOGeneratorFixEnvelopeOrigins(State->OutputScalingFactorLFO[Scan][Index],
  1740.                             ActualPreOrigin);
  1741.                         EnvelopeStateFixUpInitialDelay(State->OutputOriginAdjustEnvelope[
  1742.                             Scan][Index],ActualPreOrigin);
  1743.                         LFOGeneratorFixEnvelopeOrigins(State->OutputOriginAdjustLFO[Scan][Index],
  1744.                             ActualPreOrigin);
  1745.                     }
  1746.             }
  1747.     }
  1748.  
  1749.  
  1750. /* set a new frequency for a modulation oscillator state object.  used for */
  1751. /* portamento and modulation of frequency (vibrato) */
  1752. void                                    ModOscStateNewFrequency(ModOscStateRec* State,
  1753.                                                 float NewFrequencyHertz)
  1754.     {
  1755.         long                                Scan;
  1756.  
  1757.         CheckPtrExistence(State);
  1758.         ValidateState(State);
  1759.  
  1760.         for (Scan = 0; Scan < State->Template.NumberOfOscillators; Scan += 1)
  1761.             {
  1762.                 PRNGCHK(State->StateArray,&(State->StateArray[Scan]),
  1763.                     sizeof(State->StateArray[Scan]));
  1764.                 switch (State->StateArray[Scan].OscillatorType)
  1765.                     {
  1766.                         default:
  1767.                             EXECUTE(PRERR(ForceAbort,"ModOscStateNewFrequency:  bad oscillator type"));
  1768.                             break;
  1769.                         case eOscillatorSampled:
  1770.                             SampleStateNewFrequency(State->StateArray[Scan].u.SampleState,
  1771.                                 NewFrequencyHertz);
  1772.                             break;
  1773.                         case eOscillatorWaveTable:
  1774.                             WaveTableStateNewFrequency(State->StateArray[Scan].u.WaveTableState,
  1775.                                 NewFrequencyHertz);
  1776.                             break;
  1777.                     }
  1778.             }
  1779.     }
  1780.  
  1781.  
  1782. /* send a key-up signal to one of the oscillators */
  1783. void                                    ModOscKeyUpSustain1(ModOscStateRec* State)
  1784.     {
  1785.         long                                Scan;
  1786.  
  1787.         CheckPtrExistence(State);
  1788.         ValidateState(State);
  1789.  
  1790.         for (Scan = 0; Scan < State->Template.NumberOfOscillators; Scan += 1)
  1791.             {
  1792.                 long                                Index;
  1793.  
  1794.                 PRNGCHK(State->StateArray,&(State->StateArray[Scan]),
  1795.                     sizeof(State->StateArray[Scan]));
  1796.                 switch (State->StateArray[Scan].OscillatorType)
  1797.                     {
  1798.                         default:
  1799.                             EXECUTE(PRERR(ForceAbort,"ModOscKeyUpSustain1:  bad oscillator type"));
  1800.                             break;
  1801.                         case eOscillatorSampled:
  1802.                             SampleKeyUpSustain1(State->StateArray[Scan].u.SampleState);
  1803.                             break;
  1804.                         case eOscillatorWaveTable:
  1805.                             WaveTableKeyUpSustain1(State->StateArray[Scan].u.WaveTableState);
  1806.                             break;
  1807.                     }
  1808.  
  1809.                 for (Index = 0; Index < State->Template.PhaseGenNumElements[Scan]; Index += 1)
  1810.                     {
  1811.                         EnvelopeKeyUpSustain1(State->PhaseGenScalingFactorEnvelope[Scan][Index]);
  1812.                         LFOGeneratorKeyUpSustain1(State->PhaseGenScalingFactorLFO[Scan][Index]);
  1813.                         EnvelopeKeyUpSustain1(State->PhaseGenOriginAdjustEnvelope[Scan][Index]);
  1814.                         LFOGeneratorKeyUpSustain1(State->PhaseGenOriginAdjustLFO[Scan][Index]);
  1815.                     }
  1816.  
  1817.                 for (Index = 0; Index < State->Template.OutputNumElements[Scan]; Index += 1)
  1818.                     {
  1819.                         EnvelopeKeyUpSustain1(State->OutputScalingFactorEnvelope[Scan][Index]);
  1820.                         LFOGeneratorKeyUpSustain1(State->OutputScalingFactorLFO[Scan][Index]);
  1821.                         EnvelopeKeyUpSustain1(State->OutputOriginAdjustEnvelope[Scan][Index]);
  1822.                         LFOGeneratorKeyUpSustain1(State->OutputOriginAdjustLFO[Scan][Index]);
  1823.                     }
  1824.             }
  1825.     }
  1826.  
  1827.  
  1828. /* send a key-up signal to one of the oscillators */
  1829. void                                    ModOscKeyUpSustain2(ModOscStateRec* State)
  1830.     {
  1831.         long                                Scan;
  1832.  
  1833.         CheckPtrExistence(State);
  1834.         ValidateState(State);
  1835.  
  1836.         for (Scan = 0; Scan < State->Template.NumberOfOscillators; Scan += 1)
  1837.             {
  1838.                 long                                Index;
  1839.  
  1840.                 PRNGCHK(State->StateArray,&(State->StateArray[Scan]),
  1841.                     sizeof(State->StateArray[Scan]));
  1842.                 switch (State->StateArray[Scan].OscillatorType)
  1843.                     {
  1844.                         default:
  1845.                             EXECUTE(PRERR(ForceAbort,"ModOscKeyUpSustain2:  bad oscillator type"));
  1846.                             break;
  1847.                         case eOscillatorSampled:
  1848.                             SampleKeyUpSustain2(State->StateArray[Scan].u.SampleState);
  1849.                             break;
  1850.                         case eOscillatorWaveTable:
  1851.                             WaveTableKeyUpSustain2(State->StateArray[Scan].u.WaveTableState);
  1852.                             break;
  1853.                     }
  1854.  
  1855.                 for (Index = 0; Index < State->Template.PhaseGenNumElements[Scan]; Index += 1)
  1856.                     {
  1857.                         EnvelopeKeyUpSustain2(State->PhaseGenScalingFactorEnvelope[Scan][Index]);
  1858.                         LFOGeneratorKeyUpSustain2(State->PhaseGenScalingFactorLFO[Scan][Index]);
  1859.                         EnvelopeKeyUpSustain2(State->PhaseGenOriginAdjustEnvelope[Scan][Index]);
  1860.                         LFOGeneratorKeyUpSustain2(State->PhaseGenOriginAdjustLFO[Scan][Index]);
  1861.                     }
  1862.  
  1863.                 for (Index = 0; Index < State->Template.OutputNumElements[Scan]; Index += 1)
  1864.                     {
  1865.                         EnvelopeKeyUpSustain2(State->OutputScalingFactorEnvelope[Scan][Index]);
  1866.                         LFOGeneratorKeyUpSustain2(State->OutputScalingFactorLFO[Scan][Index]);
  1867.                         EnvelopeKeyUpSustain2(State->OutputOriginAdjustEnvelope[Scan][Index]);
  1868.                         LFOGeneratorKeyUpSustain2(State->OutputOriginAdjustLFO[Scan][Index]);
  1869.                     }
  1870.             }
  1871.     }
  1872.  
  1873.  
  1874. /* send a key-up signal to one of the oscillators */
  1875. void                                    ModOscKeyUpSustain3(ModOscStateRec* State)
  1876.     {
  1877.         long                                Scan;
  1878.  
  1879.         CheckPtrExistence(State);
  1880.         ValidateState(State);
  1881.  
  1882.         for (Scan = 0; Scan < State->Template.NumberOfOscillators; Scan += 1)
  1883.             {
  1884.                 long                                Index;
  1885.  
  1886.                 PRNGCHK(State->StateArray,&(State->StateArray[Scan]),
  1887.                     sizeof(State->StateArray[Scan]));
  1888.                 switch (State->StateArray[Scan].OscillatorType)
  1889.                     {
  1890.                         default:
  1891.                             EXECUTE(PRERR(ForceAbort,"ModOscKeyUpSustain3:  bad oscillator type"));
  1892.                             break;
  1893.                         case eOscillatorSampled:
  1894.                             SampleKeyUpSustain3(State->StateArray[Scan].u.SampleState);
  1895.                             break;
  1896.                         case eOscillatorWaveTable:
  1897.                             WaveTableKeyUpSustain3(State->StateArray[Scan].u.WaveTableState);
  1898.                             break;
  1899.                     }
  1900.  
  1901.                 for (Index = 0; Index < State->Template.PhaseGenNumElements[Scan]; Index += 1)
  1902.                     {
  1903.                         EnvelopeKeyUpSustain3(State->PhaseGenScalingFactorEnvelope[Scan][Index]);
  1904.                         LFOGeneratorKeyUpSustain3(State->PhaseGenScalingFactorLFO[Scan][Index]);
  1905.                         EnvelopeKeyUpSustain3(State->PhaseGenOriginAdjustEnvelope[Scan][Index]);
  1906.                         LFOGeneratorKeyUpSustain3(State->PhaseGenOriginAdjustLFO[Scan][Index]);
  1907.                     }
  1908.  
  1909.                 for (Index = 0; Index < State->Template.OutputNumElements[Scan]; Index += 1)
  1910.                     {
  1911.                         EnvelopeKeyUpSustain3(State->OutputScalingFactorEnvelope[Scan][Index]);
  1912.                         LFOGeneratorKeyUpSustain3(State->OutputScalingFactorLFO[Scan][Index]);
  1913.                         EnvelopeKeyUpSustain3(State->OutputOriginAdjustEnvelope[Scan][Index]);
  1914.                         LFOGeneratorKeyUpSustain3(State->OutputOriginAdjustLFO[Scan][Index]);
  1915.                     }
  1916.             }
  1917.     }
  1918.  
  1919.  
  1920. /* restart a modulation oscillator oscillator.  this is used for tie continuations */
  1921. void                                    RestartModOscState(ModOscStateRec* State,
  1922.                                                 float NewFreqMultisampling, float NewAccent1, float NewAccent2,
  1923.                                                 float NewAccent3, float NewAccent4, float NewLoudness,
  1924.                                                 float NewHurryUp, MyBoolean RetriggerEnvelopes,
  1925.                                                 float NewStereoPosition, float NewInitialFrequency)
  1926.     {
  1927.         long                                Scan;
  1928.  
  1929.         CheckPtrExistence(State);
  1930.         ValidateState(State);
  1931.  
  1932.         for (Scan = 0; Scan < State->Template.NumberOfOscillators; Scan += 1)
  1933.             {
  1934.                 long                                Index;
  1935.  
  1936.                 PRNGCHK(State->StateArray,&(State->StateArray[Scan]),
  1937.                     sizeof(State->StateArray[Scan]));
  1938.                 switch (State->StateArray[Scan].OscillatorType)
  1939.                     {
  1940.                         default:
  1941.                             EXECUTE(PRERR(ForceAbort,"RestartModOscState:  bad oscillator type"));
  1942.                             break;
  1943.                         case eOscillatorSampled:
  1944.                             RestartSampleState(State->StateArray[Scan].u.SampleState,
  1945.                                 NewFreqMultisampling,NewAccent1,NewAccent2,NewAccent3,NewAccent4,
  1946.                                 NewLoudness,NewHurryUp,RetriggerEnvelopes,NewStereoPosition,
  1947.                                 NewInitialFrequency);
  1948.                             break;
  1949.                         case eOscillatorWaveTable:
  1950.                             RestartWaveTableState(State->StateArray[Scan].u.WaveTableState,
  1951.                                 NewFreqMultisampling,NewAccent1,NewAccent2,NewAccent3,NewAccent4,
  1952.                                 NewLoudness,NewHurryUp,RetriggerEnvelopes,NewStereoPosition,
  1953.                                 NewInitialFrequency);
  1954.                             break;
  1955.                     }
  1956.  
  1957.                 for (Index = 0; Index < State->Template.PhaseGenNumElements[Scan]; Index += 1)
  1958.                     {
  1959.                         EnvelopeRetriggerFromOrigin(State->PhaseGenScalingFactorEnvelope[Scan][Index],
  1960.                             NewAccent1,NewAccent2,NewAccent3,NewAccent4,NewInitialFrequency,
  1961.                             1,NewHurryUp,State->Template.TicksPerSecond,RetriggerEnvelopes);
  1962.                         LFOGeneratorRetriggerFromOrigin(State->PhaseGenScalingFactorLFO[Scan][Index],
  1963.                             NewAccent1,NewAccent2,NewAccent3,NewAccent4,NewInitialFrequency,
  1964.                             NewHurryUp,State->Template.TicksPerSecond,1,1,RetriggerEnvelopes);
  1965.                         EnvelopeRetriggerFromOrigin(State->PhaseGenOriginAdjustEnvelope[Scan][Index],
  1966.                             NewAccent1,NewAccent2,NewAccent3,NewAccent4,NewInitialFrequency,
  1967.                             1,NewHurryUp,State->Template.TicksPerSecond,RetriggerEnvelopes);
  1968.                         LFOGeneratorRetriggerFromOrigin(State->PhaseGenOriginAdjustLFO[Scan][Index],
  1969.                             NewAccent1,NewAccent2,NewAccent3,NewAccent4,NewInitialFrequency,
  1970.                             NewHurryUp,State->Template.TicksPerSecond,1,1,RetriggerEnvelopes);
  1971.                     }
  1972.  
  1973.                 for (Index = 0; Index < State->Template.OutputNumElements[Scan]; Index += 1)
  1974.                     {
  1975.                         EnvelopeRetriggerFromOrigin(State->OutputScalingFactorEnvelope[Scan][Index],
  1976.                             NewAccent1,NewAccent2,NewAccent3,NewAccent4,NewInitialFrequency,
  1977.                             1,NewHurryUp,State->Template.TicksPerSecond,RetriggerEnvelopes);
  1978.                         LFOGeneratorRetriggerFromOrigin(State->OutputScalingFactorLFO[Scan][Index],
  1979.                             NewAccent1,NewAccent2,NewAccent3,NewAccent4,NewInitialFrequency,
  1980.                             NewHurryUp,State->Template.TicksPerSecond,1,1,RetriggerEnvelopes);
  1981.                         EnvelopeRetriggerFromOrigin(State->OutputOriginAdjustEnvelope[Scan][Index],
  1982.                             NewAccent1,NewAccent2,NewAccent3,NewAccent4,NewInitialFrequency,
  1983.                             1,NewHurryUp,State->Template.TicksPerSecond,RetriggerEnvelopes);
  1984.                         LFOGeneratorRetriggerFromOrigin(State->OutputOriginAdjustLFO[Scan][Index],
  1985.                             NewAccent1,NewAccent2,NewAccent3,NewAccent4,NewInitialFrequency,
  1986.                             NewHurryUp,State->Template.TicksPerSecond,1,1,RetriggerEnvelopes);
  1987.                     }
  1988.             }
  1989.     }
  1990.  
  1991.  
  1992. /* generate a sequence of samples (called for each envelope clock) */
  1993. void                                    ModOscGenSamples(ModOscStateRec* State,
  1994.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1995.     {
  1996.         CheckPtrExistence(State);
  1997.         ValidateState(State);
  1998.  
  1999.         if (State->Template.StereoPlayback)
  2000.             {
  2001.                 PRNGCHK(RawBuffer,RawBuffer,SampleCount * 2 * sizeof(largefixedsigned));
  2002.             }
  2003.          else
  2004.             {
  2005.                 PRNGCHK(RawBuffer,RawBuffer,SampleCount * sizeof(largefixedsigned));
  2006.             }
  2007.         while (SampleCount > 0)
  2008.             {
  2009.                 long                                Scan;
  2010.                 float*                            Temp;
  2011.  
  2012.                 for (Scan = 0; Scan < State->Template.NumberOfOscillators; Scan += 1)
  2013.                     {
  2014.                         PRNGCHK(State->StateArray,&(State->StateArray[Scan]),
  2015.                             sizeof(State->StateArray[Scan]));
  2016.                         PRNGCHK(State->BuildOldValues,&(State->BuildOldValues[Scan]),
  2017.                             sizeof(State->BuildOldValues[Scan]));
  2018.                         switch (State->StateArray[Scan].OscillatorType)
  2019.                             {
  2020.                                 default:
  2021.                                     EXECUTE(PRERR(ForceAbort,"ModOscGenSamples:  bad oscillator type"));
  2022.                                     break;
  2023.                                 case eOscillatorSampled:
  2024.                                     State->BuildOldValues[Scan] = SampleGenOneSample(
  2025.                                         State->StateArray[Scan].u.SampleState,
  2026.                                         State->Template.PhaseGenModulateHow[Scan],
  2027.                                         State->PhaseGenModulationScaling[Scan],
  2028.                                         State->PhaseGenModulationOrigin[Scan],
  2029.                                         State->OldValues,
  2030.                                         State->Template.PhaseGenIndirectionTable[Scan],
  2031.                                         State->Template.PhaseGenNumElements[Scan],
  2032.                                         State->Template.OutputModulateHow[Scan],
  2033.                                         State->OutputModulationScaling[Scan],
  2034.                                         State->OutputModulationOrigin[Scan],
  2035.                                         State->OldValues,
  2036.                                         State->Template.OutputIndirectionTable[Scan],
  2037.                                         State->Template.OutputNumElements[Scan],
  2038.                                         RawBuffer);
  2039.                                     break;
  2040.                                 case eOscillatorWaveTable:
  2041.                                     State->BuildOldValues[Scan] = WaveTableGenOneSample(
  2042.                                         State->StateArray[Scan].u.WaveTableState,
  2043.                                         State->Template.PhaseGenModulateHow[Scan],
  2044.                                         State->PhaseGenModulationScaling[Scan],
  2045.                                         State->PhaseGenModulationOrigin[Scan],
  2046.                                         State->OldValues,
  2047.                                         State->Template.PhaseGenIndirectionTable[Scan],
  2048.                                         State->Template.PhaseGenNumElements[Scan],
  2049.                                         State->Template.OutputModulateHow[Scan],
  2050.                                         State->OutputModulationScaling[Scan],
  2051.                                         State->OutputModulationOrigin[Scan],
  2052.                                         State->OldValues,
  2053.                                         State->Template.OutputIndirectionTable[Scan],
  2054.                                         State->Template.OutputNumElements[Scan],
  2055.                                         RawBuffer);
  2056.                                     break;
  2057.                             }
  2058.                     }
  2059.                 if (State->Template.StereoPlayback)
  2060.                     {
  2061.                         RawBuffer += 2;
  2062.                     }
  2063.                  else
  2064.                     {
  2065.                         RawBuffer += 1;
  2066.                     }
  2067.                 SampleCount -= 1;
  2068.                 Temp = State->BuildOldValues;
  2069.                 State->BuildOldValues = State->OldValues;
  2070.                 State->OldValues = Temp;
  2071.             }
  2072.     }
  2073.  
  2074.  
  2075. /* find out if the modulation oscillator has finished */
  2076. MyBoolean                            ModOscIsItFinished(ModOscStateRec* State)
  2077.     {
  2078.         long                                Scan;
  2079.  
  2080.         CheckPtrExistence(State);
  2081.         ValidateState(State);
  2082.  
  2083.         for (Scan = 0; Scan < State->Template.NumberOfOscillators; Scan += 1)
  2084.             {
  2085.                 PRNGCHK(State->StateArray,&(State->StateArray[Scan]),
  2086.                     sizeof(State->StateArray[Scan]));
  2087.                 if (State->StateArray[Scan].OscillatorType == eOscillatorSampled)
  2088.                     {
  2089.                         if (!SampleIsItFinished(State->StateArray[Scan].u.SampleState))
  2090.                             {
  2091.                                 return False; /* someone is still running */
  2092.                             }
  2093.                     }
  2094.                  else
  2095.                     {
  2096.                         if (!WaveTableIsItFinished(State->StateArray[Scan].u.WaveTableState))
  2097.                             {
  2098.                                 return False; /* someone is still running */
  2099.                             }
  2100.                     }
  2101.             }
  2102.  
  2103.         return True; /* nobody is still running */
  2104.     }
  2105.